package ecoparasite.svg;

import ecoparasite.svg.elements.Element;
import ecoparasite.svg.elements.ElementsFactory;
import ecoparasite.svg.elements.Line;
import ecoparasite.svg.elements.Text;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class SVGAxes {

    final int SIZE_TICK_TEXT = ElementsFactory.AXES_TEXT_SIZE - 3;

    private ArrayList<Double> pointsX;
    private ArrayList<Double> pointsY;
    private Double offsetX;
    private Double offsetY;
    private SVGResizing resizer;

    private Double minPointsX;
    private Double minPointsY;
    private Double maxPointsX;
    private Double maxPointsY;

    public SVGAxes( HashMap<String, ArrayList<Double>> axesPoints ) throws IncorrectAxesPointsException {

        if( axesPoints.get("AxeX") == null ||  axesPoints.get("AxeY") == null || axesPoints.get("OffsetX") == null || axesPoints.get("OffsetY") == null ){
            throw new IncorrectAxesPointsException();
        }

        this.pointsX = axesPoints.get("AxeX");
        this.pointsY = axesPoints.get("AxeY");
        this.offsetX = axesPoints.get("OffsetX").getFirst();
        this.offsetY = axesPoints.get("OffsetY").getFirst();

        this.minPointsX = this.pointsX.getFirst();
        this.minPointsY = this.pointsY.getFirst();
        this.maxPointsX = this.pointsX.getLast();
        this.maxPointsY = this.pointsY.getLast();

    }

    public ArrayList<Double> getPointsX() {
        return pointsX;
    }

    public ArrayList<Double> getPointsY() {
        return pointsY;
    }

    public Double getOffsetX() {
        return offsetX;
    }

    public Double getOffsetY() {
        return offsetY;
    }

    public SVGResizing getResizer() {
        if( this.resizer == null ){
            this.resizer = new SVGResizing( this.minPointsX, this.minPointsY, this.maxPointsX, this.maxPointsY );
        }
        return resizer;
    }

    public void setResizer(SVGResizing resizer) {
        this.resizer = resizer;
    }

    public ArrayList<Element> buildAll(String XLabel, String YLabel){

        ArrayList<Element> elements = new ArrayList<>();
        elements.addAll(buildAxes(XLabel, YLabel));
        elements.addAll(buildXTicks());
        elements.addAll(buildYTicks());

        return elements;
    }

    public ArrayList<Element> buildAxes(String XLabel, String YLabel){

        final int OFFSET_TEXT_AXISX_X = -20;
        final int OFFSET_TEXT_AXISX_Y = -10;
        final int OFFSET_TEXT_AXISY_X = +5;
        final int OFFSET_TEXT_AXISY_Y = +10;

        ArrayList<Element> elements = new ArrayList<>();

        double beginAxeX = getBeginAxeX();
        double beginAxeY = getBeginAxeY();

        Coordonnees bottom = getResizer().resize( beginAxeX, minPointsY );
        Coordonnees top = getResizer().resize( beginAxeX, maxPointsY );
        Coordonnees left = getResizer().resize( minPointsX, beginAxeY );
        Coordonnees right = getResizer().resize( maxPointsX, beginAxeY );

        // Axes
        elements.add( new Line( bottom, top, ElementsFactory.COLOR_BLACK, 2 ) );
        elements.add( new Line( left, right, ElementsFactory.COLOR_BLACK, 2 ) );

        // Labels.
        elements.add( new Text(
           new Coordonnees( right.getX() + OFFSET_TEXT_AXISX_X, right.getY() + OFFSET_TEXT_AXISX_Y ),
           XLabel, ElementsFactory.COLOR_BLACK, ElementsFactory.AXES_TEXT_SIZE
        ) );
        elements.add( new Text(
                new Coordonnees( top.getX() + OFFSET_TEXT_AXISY_X, top.getY() + OFFSET_TEXT_AXISY_Y ),
                YLabel, ElementsFactory.COLOR_BLACK, ElementsFactory.AXES_TEXT_SIZE
        ));

        return elements;

    }

    public ArrayList<Element> buildXTicks(){

        final int OFFSET_TICK = -5;
        final int OFFSET_TEXT_X = -10;
        final int OFFSET_TEXT_Y = +15;

        ArrayList<Element> elements = new ArrayList<>();

        double beginAxeY = getBeginAxeY();
        for( Double X : this.pointsX ){
            Coordonnees coords = getResizer().resize( X, beginAxeY );

            elements.add(new Line(
                    coords,
                    new Coordonnees( coords.getX(), coords.getY() + OFFSET_TICK ),
                    ElementsFactory.COLOR_BLACK, 1
            ));
            elements.add(new Text(
               new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                X.toString(),
                ElementsFactory.COLOR_BLACK,
                SIZE_TICK_TEXT
            ));
        }

        return elements;
    }

    public ArrayList<Element> buildYTicks(){

        final int OFFSET_TICK = +5;
        final int OFFSET_TEXT_X = -35;
        final int OFFSET_TEXT_Y = +5;

        ArrayList<Element> elements = new ArrayList<>();

        double beginAxeX = getBeginAxeX();
        for( Double Y : this.pointsY ){
            Coordonnees coords = getResizer().resize( beginAxeX, Y );

            elements.add(new Line(
                    new Coordonnees(coords.getX() + OFFSET_TICK, coords.getY() ),
                    coords,
                    ElementsFactory.COLOR_BLACK, 1
            ));
            elements.add(new Text(
                    new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                    Y.toString(),
                    ElementsFactory.COLOR_BLACK,
                    SIZE_TICK_TEXT
            ));
        }

        return elements;
    }

    private double getBeginAxeX(){
        return ( minPointsX > 0 ) ? minPointsX : ( maxPointsX < 0 ? maxPointsX : 0 );
    }

    private double getBeginAxeY(){
        return ( minPointsY > 0 ) ? minPointsY : ( maxPointsY < 0 ? maxPointsY : 0 );
    }
}