using OpenCvSharp;

namespace SimulationCommon;

public class Rectangular_Area_Search_Function
{
    public static double MokatuoLon(double Lon)
    {
        double R = 6378.137;
        double y = R * Math.Log(Math.Tan((Lon + 90) * Math.PI / 360));
        return y;
    }

    public static double MokatuoLat(double Lat)
    {
        double R = 6378.137;
        double x = (Lat * Math.PI * R) / 180;
        return x;
    }

    //反墨卡托投影
    public static double RMokatuoLon(double y)
    {
        double R = 6378.137;
        double lon = Math.Atan(Math.Exp(y / R)) * 360 / Math.PI - 90;
        return lon;
    }

    public static double RMokatuoLat(double x)
    {
        double R = 6378.137;
        double lat = x * 180 / (R * Math.PI);
        return lat;
    }

    private static double[] GetLinearEquation(Point2f point1, Point2f point2)
    {
        double sign = 1;
        double parameter_a = point2.Y - point1.Y;

        if (parameter_a < 0)
        {
            sign = -1;
            parameter_a = sign * parameter_a;
        }

        double parameter_b = sign * (point1.X - point2.X);
        double parameter_c = sign * (point1.Y * point2.X - point1.X * point2.Y);

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetParallelLine(Point2f point, double[] line)
    {
        double parameter_a = line[0];
        double parameter_b = line[1];
        double parameter_c = -point.X * parameter_a - point.Y * parameter_b;

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetpPerpendicular(Point2f point, double[] line)
    {
        double parameter_a = line[1];
        double parameter_b = -line[0];
        double parameter_c = -point.Y * parameter_b - point.X * parameter_a;

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetCrossPoint(double[] line1, double[] line2)
    {
        double cross_y = (line1[2] * line2[0] - line2[2] * line1[0]) / (line1[0] * line2[1] - line2[0] * line1[1]);
        double cross_x = (line2[2] * line1[1] - line1[2] * line2[1]) / (line1[0] * line2[1] - line2[0] * line1[1]);

        return new double[] { cross_x, cross_y };
    }

    private static double GetDistance(Point2f point, double[] line)
    {
        return Math.Abs(line[0] * point.X + line[1] * point.Y + line[2]) /
               Math.Sqrt(Math.Pow(line[0], 2) + Math.Pow(line[1], 2));
    }

    private static int CheckDirection(Point2f point, double[] line)
    {
        double result = line[0] * point.X + line[1] * point.Y + line[2];
        if (result < 0) return -1;
        if (result > 0) return 1;
        return 0;
    }

    private static double GetRectangularArea(double[] Point0, double[] Point1, double[] Point2, double[] Point3)
    {
        double width = Math.Sqrt(Math.Pow(Point0[0] - Point1[0], 2) + Math.Pow(Point0[1] - Point1[1], 2));
        double height = Math.Sqrt(Math.Pow(Point1[0] - Point2[0], 2) + Math.Pow(Point1[1] - Point2[1], 2));
        return width * height;
    }

    public static Point2f[] GetConvexHull(List<Point2f> pointList)
    {
        Point2f[] hull = Cv2.ConvexHull(pointList);
        return hull;
    }

    public static Tuple<Point2f[], double> MinEnclosingRectangle(Point2f[] hull)
    {
        double min_rectangular_area = double.PositiveInfinity;
        Point2f[] Point_muster = new Point2f[4];

        for (int num = 0; num < hull.Length - 1; num++)
        {
            double[] Base_line = GetLinearEquation(hull[num], hull[num + 1]);
            double max_Ditance = 0;
            Point2f Point = hull[num + 1];

            foreach (Point2f i_point in hull)
            {
                if ((i_point.X == hull[num].X && i_point.Y == hull[num].Y) ||
                    (i_point.X == hull[num + 1].X && i_point.Y == hull[num + 1].Y))
                {
                    continue;
                }

                double distance = GetDistance(i_point, Base_line);

                if (distance > max_Ditance)
                {
                    max_Ditance = distance;
                    Point = i_point;
                }
            }

            double[] line_Parallel_Base = GetParallelLine(Point, Base_line);

            double[] line_Perpendicular_Base_right = null;
            double[] line_Perpendicular_Base_left = null;

            foreach (Point2f j_point in hull)
            {
                double[] line_Preparatory = GetpPerpendicular(j_point, Base_line);
                int point_right = 0;
                int point_left = 0;

                foreach (Point2f k_point in hull)
                {
                    if (k_point.X == j_point.X && k_point.Y == j_point.Y)
                    {
                        continue;
                    }

                    if (CheckDirection(k_point, line_Preparatory) < 0)
                    {
                        point_left++;
                    }
                    else
                    {
                        point_right++;
                    }
                }

                if (point_right == hull.Length - 1)
                {
                    line_Perpendicular_Base_right = line_Preparatory;
                }

                if (point_left == hull.Length - 1)
                {
                    line_Perpendicular_Base_left = line_Preparatory;
                }
            }

            double[] Point0 = GetCrossPoint(Base_line, line_Perpendicular_Base_left);
            double[] Point1 = GetCrossPoint(Base_line, line_Perpendicular_Base_right);
            double[] Point2 = GetCrossPoint(line_Parallel_Base, line_Perpendicular_Base_right);
            double[] Point3 = GetCrossPoint(line_Parallel_Base, line_Perpendicular_Base_left);
            double rectangular_area = GetRectangularArea(Point0, Point1, Point2, Point3);

            if (rectangular_area < min_rectangular_area)
            {
                min_rectangular_area = rectangular_area;
                Point_muster = new Point2f[]
                {
                    new Point2f((float)Point0[0], (float)Point0[1]),
                    new Point2f((float)Point1[0], (float)Point1[1]),
                    new Point2f((float)Point2[0], (float)Point2[1]),
                    new Point2f((float)Point3[0], (float)Point3[1])
                };
            }
        }

        return Tuple.Create(Point_muster, min_rectangular_area);
    }
}