using OpenCvSharp;

namespace SimulationCommon;

public class WeatherResponse
{
    public Wind Wind { get; set; }
}

public class Wind
{
    public double Speed { get; set; }
    public double Deg { get; set; }
}

public class CurrentResponse
{
    public Current Current { get; set; }
}

public class Current
{
    public double Speed { get; set; }
    public double Direction { get; set; }
}


public class SeaSJ
{
    // 生成符合正态分布的随机数
    public static double NormalDistributionRandom(double mu, double sigma)
    {
        Random rand = new Random();
        double u1 = 1.0 - rand.NextDouble(); // uniform(0,1] random doubles
        double u2 = 1.0 - rand.NextDouble();
        double normalRandom = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2); // random normal(0,1)
        return mu + sigma * normalRandom; // random normal(mean,stdDev^2)
    }

    // 交付类方法
    public static List<double[]> GetDrift(double[] initialPosition, double dt, double totalTime)
    {
        // run 获取轨迹的函数
        // initialPosition --> 初始位置; dt --> 时间步长; totalTime --> 总时长
        List<double[]> trajectory = CalculateDriftTrajectory(initialPosition, dt, totalTime);
        return trajectory;
    }

    public static List<double[]> CalculateDriftTrajectory(double[] initialPosition, double dt, double totalTime)
    {
        int timeSteps = (int)(totalTime / dt);
        List<double[]> trajectory = new List<double[]>();
        trajectory.Add(new double[] { initialPosition[0], initialPosition[1] });

        for (int t = 1; t < timeSteps; t++)
        {
            double[] currentPos = trajectory[t - 1];

            // 动态获取当前位置的风力和洋流数据
            double[] windVelocity = GetWindVelocityFromAPI(currentPos[0], currentPos[1], t);
            double[] currentVelocity = GetCurrentVelocityFromAPI(currentPos[0], currentPos[1], t);

            // 计算漂移速度
            double[] driftVelocity =
            {
                currentVelocity[0] + windVelocity[0],
                currentVelocity[1] + windVelocity[1]
            };

            // 更新位置（假设漂移速度是海里每小时，需要转换成经纬度的变化量）
            double[] newPosition =
            {
                currentPos[0] + (driftVelocity[0] * dt / 60.0), // 纬度变化量
                currentPos[1] + (driftVelocity[1] * dt / 60.0) // 经度变化量
            };

            trajectory.Add(newPosition);
        }

        return trajectory;
    }

    public static double[] GetWindVelocityFromAPI(double latitude, double longitude, int time)
    {
        // 风力数据来自于 double latitude, double longitude, string time
        WeatherResponse weatherResponse = new WeatherResponse() { };

        double windSpeed = weatherResponse.Wind.Speed;
        double windDirection = weatherResponse.Wind.Deg;

        // 将风速和风向转换为X和Y分量（单位：海里每小时）
        double windSpeedInKnots = windSpeed / 1.852;
        double windDirectionInRadians = windDirection * (Math.PI / 180);
        double windX = windSpeedInKnots * Math.Cos(windDirectionInRadians);
        double windY = windSpeedInKnots * Math.Sin(windDirectionInRadians);

        return new double[] { windX, windY };
    }

    public static double[] GetCurrentVelocityFromAPI(double latitude, double longitude, int time)
    {
        // 洋流数据来自于 double latitude, double longitude, string time
        CurrentResponse currentResponse = new CurrentResponse() { };

        double currentSpeed = currentResponse.Current.Speed;
        double currentDirection = currentResponse.Current.Direction;

        // 将洋流速度和方向转换为X和Y分量（单位：海里每小时）
        double currentSpeedInKnots = currentSpeed / 1.852;
        double currentDirectionInRadians = currentDirection * (Math.PI / 180);
        double currentX = currentSpeedInKnots * Math.Cos(currentDirectionInRadians);
        double currentY = currentSpeedInKnots * Math.Sin(currentDirectionInRadians);

        return new double[] { currentX, currentY };
    }
    
    // 交付部分方法代码
    public static Tuple<Point2f[], double> getminEnclosingRect(List<Tuple<double, double>> latLonList)
    {
        // 转换经纬度为墨卡托投影坐标，并添加到点集合
        List<Point2f> pointList = new List<Point2f>();
        foreach (var latLon in latLonList)
        {
            double x = Rectangular_Area_Search_Function.MokatuoLat(latLon.Item1);
            double y = Rectangular_Area_Search_Function.MokatuoLon(latLon.Item2);
            pointList.Add(new Point2f((float)x, (float)y));
        }

        // 获取凸包
        Point2f[] convexHull = Rectangular_Area_Search_Function.GetConvexHull(pointList);

        // 计算最小包围矩形
        Tuple<Point2f[], double> minEnclosingRect = Rectangular_Area_Search_Function.MinEnclosingRectangle(convexHull);

        return minEnclosingRect;

    }
}