package ovh.gasser.newshapes.shapes;

import org.junit.jupiter.api.Test;
import ovh.gasser.newshapes.attributes.ColorAttributes;
import ovh.gasser.newshapes.attributes.SelectionAttributes;

import java.awt.Color;
import java.awt.Point;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

class SPolygonTest {

    private static final String POLYGON_CLASS = "ovh.gasser.newshapes.shapes.SPolygon";

    @Test
    void testCreateWithListOfPoints() {
        assumeTrue(isPolygonAvailable(), "SPolygon is not present in this checkout");

        var polygon = createPolygon(List.of(
                new Point(10, 10),
                new Point(20, 30),
                new Point(40, 15)
        ));

        assertNotNull(polygon);
        assertEquals(List.of(new Point(10, 10), new Point(20, 30), new Point(40, 15)), pointsOf(polygon));
    }

    @Test
    void testCreateWithVarargs() {
        assumeTrue(isPolygonAvailable(), "SPolygon is not present in this checkout");

        var polygon = createPolygon(new Point(5, 5), new Point(15, 25), new Point(35, 10));

        assertNotNull(polygon);
        assertEquals(List.of(new Point(5, 5), new Point(15, 25), new Point(35, 10)), pointsOf(polygon));
    }

    @Test
    void testDefaultAttributesAdded() {
        assumeTrue(isPolygonAvailable(), "SPolygon is not present in this checkout");

        var polygon = createPolygon(new Point(0, 0), new Point(10, 0), new Point(5, 10));

        assertNotNull(getAttribute(polygon, SelectionAttributes.ID));
        var colorAttrs = (ColorAttributes) getAttribute(polygon, ColorAttributes.ID);
        assertNotNull(colorAttrs);
        assertEquals(false, colorAttrs.filled);
        assertEquals(true, colorAttrs.stroked);
        assertEquals(Color.BLACK, colorAttrs.filledColor);
        assertEquals(Color.BLACK, colorAttrs.strokedColor);
    }

    @Test
    void testGetPointsReturnsUnmodifiableList() {
        assumeTrue(isPolygonAvailable(), "SPolygon is not present in this checkout");

        var polygon = createPolygon(new Point(0, 0), new Point(10, 0), new Point(5, 10));

        assertThrows(UnsupportedOperationException.class,
                () -> pointsOf(polygon).add(new Point(1, 1)));
    }

    @Test
    void testGetPointsReturnsCorrectPoints() {
        assumeTrue(isPolygonAvailable(), "SPolygon is not present in this checkout");

        var polygon = createPolygon(Arrays.asList(
                new Point(1, 2),
                new Point(3, 4),
                new Point(5, 6),
                new Point(7, 8)
        ));

        assertEquals(Arrays.asList(
                new Point(1, 2),
                new Point(3, 4),
                new Point(5, 6),
                new Point(7, 8)
        ), pointsOf(polygon));
    }

    private static Object createPolygon(Point... points) {
        return createPolygon(Arrays.asList(points));
    }

    private static Object createPolygon(List<Point> points) {
        try {
            Class<?> polygonClass = Class.forName(POLYGON_CLASS);
            try {
                Method createWithList = polygonClass.getMethod("create", List.class);
                return createWithList.invoke(null, points);
            } catch (NoSuchMethodException ignored) {
                Method createWithVarargs = polygonClass.getMethod("create", Point[].class);
                return createWithVarargs.invoke(null, (Object) points.toArray(new Point[0]));
            }
        } catch (InvocationTargetException e) {
            if (e.getCause() instanceof RuntimeException runtimeException) {
                throw runtimeException;
            }
            throw new IllegalStateException(e.getCause());
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException(e);
        }
    }

    private static boolean isPolygonAvailable() {
        try {
            Class.forName(POLYGON_CLASS);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    private static Object getAttribute(Object polygon, String id) {
        try {
            Method getAttributes = polygon.getClass().getMethod("getAttributes", String.class);
            return getAttributes.invoke(polygon, id);
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException(e);
        }
    }

    @SuppressWarnings("unchecked")
    private static List<Point> pointsOf(Object polygon) {
        try {
            Method getPoints = polygon.getClass().getMethod("getPoints");
            return (List<Point>) getPoints.invoke(polygon);
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException(e);
        }
    }
}