using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Bentley.GeometryNET;
using Bentley.MstnPlatformNET;


using Newtonsoft.Json;

namespace RingPlacementAddin
{
    //[JsonObject(MemberSerialization.OptIn)]
    internal class RingInfo
    {
        [JsonProperty("name")]
        public string Name { get; set; }

        [JsonProperty("transform")]
        public List<List<double>> Transform { get; set; }

        //[JsonProperty("Translation")]
        //public List<double> Translation { get; set; }

        //public DPoint3d Origin
        //{
        //    get
        //    {
        //        if (Translation == null || Translation.Count != 3)
        //            throw new ArgumentException("Translation must be a list of three doubles.");
        //        double uorMeter = Session.Instance.GetActiveDgnModel().GetModelInfo().UorPerMeter;

        //        return DPoint3d.FromXYZ(Translation[0], Translation[1], Translation[2]) * uorMeter;
        //    }
        //}

        [JsonIgnore]
        public DTransform3d Transform3d => ToTransform3d(Transform);

        //private DTransform3d ToTransform3d()
        //{
        //    var translation = DTransform3d.Identity;
        //    translation.Translation = Origin;
        //    DTransform3d rotation = DTransform3d.FromRotationAroundLine(DPoint3d.Zero, Axis, Angle.FromDegrees(Degrees));
        //    return DTransform3d.Multiply(translation, rotation);
        //}
        private DTransform3d ToTransform3d(List<List<double>> transform)
        {
            StringBuilder sb = new StringBuilder();

            if (transform.Count != 4 || transform.Any(t => t.Count != 4))
                throw new ArgumentException("Invalid transform format. Expected a 4x4 matrix.");
            double uorMeter = Session.Instance.GetActiveDgnModel().GetModelInfo().UorPerMeter;
            var trans = DTransform3d.Identity;
            var origin = DPoint3d.FromXYZ(
               transform[0][3],
               transform[1][3],
               transform[2][3]) * uorMeter;
            trans.Translation = origin;
            //Z轴的旋转角度，偏航角，yaw
            var zAngle = Math.Atan2(transform[1][0], transform[0][0]);
            //X轴的旋转角度，俯仰角，pitch
            var xAngle = Math.Atan2(transform[2][1], transform[2][2]);
            //Y轴的旋转角度，滚转角，roll
            var yAngle = Math.Atan2(transform[2][0], transform[0][0]);

            var ax = Angle.FromRadians(xAngle);
            var ay = Angle.FromRadians(yAngle);
            var az = Angle.FromRadians(zAngle);
            sb.AppendLine($"{Name}：修正前：X夹角: {ax.Degrees}, Y夹角: {ay.Degrees}, Z夹角: {az.Degrees}");

            if (Math.Abs(ay.Degrees) > 90)
            {
                if (ay.Degrees > 90)
                {
                    ay = Angle.FromDegrees(180 - ay.Degrees);
                }
                else
                {
                    ay = Angle.FromDegrees(-180 - ay.Degrees);
                }
                //ax += Angle.FromDegrees(180);
                //az += Angle.FromDegrees(180);
            }
            //if (ay.Degrees < -90)
            //{
            //    ay = Angle.FromDegrees(180 + ay.Degrees);
            //}
            sb.AppendLine($"{Name}：修正后：X夹角: {ax.Degrees}, Y夹角: {ay.Degrees}, Z夹角: {az.Degrees}");
            sb.AppendLine();
            var rox = DTransform3d.Rotation(0, ax);
            var roy = DTransform3d.Rotation(1, ay);
            var roz = DTransform3d.Rotation(2, az);
            var d1 = DTransform3d.Multiply(roy, roz);
            var d2 = DTransform3d.Multiply(rox, d1);
            var fin = DTransform3d.Multiply(trans, d2);
            //sb.AppendLine($"绕X轴变换矩阵ColumnX: {rox.ColumnX}");
            //sb.AppendLine($"绕X轴变换矩阵ColumnY: {rox.ColumnY}");
            //sb.AppendLine($"绕X轴变换矩阵ColumnZ: {rox.ColumnZ}");
            //sb.AppendLine($"绕Y轴变换矩阵ColumnX: {roy.ColumnX};");
            //sb.AppendLine($"绕Y轴变换矩阵ColumnY: {roy.ColumnY};");
            //sb.AppendLine($"绕Y轴变换矩阵ColumnZ: {roy.ColumnZ};");
            //sb.AppendLine($"绕Z轴变换矩阵ColumnX: {roz.ColumnX}");
            //sb.AppendLine($"绕Z轴变换矩阵ColumnY: {roz.ColumnY}");
            //sb.AppendLine($"绕Z轴变换矩阵ColumnZ: {roz.ColumnZ}");
            //sb.AppendLine($"绕Y轴和Z轴变换矩阵ColumnX: {d1.ColumnX}");
            //sb.AppendLine($"绕Y轴和Z轴变换矩阵ColumnY: {d1.ColumnY}");
            //sb.AppendLine($"绕Y轴和Z轴变换矩阵ColumnZ: {d1.ColumnZ}");
            //sb.AppendLine($"绕Z，Y，X轴旋转矩阵ColumnX: {d2.ColumnX}");
            //sb.AppendLine($"绕Z，Y，X轴旋转矩阵ColumnY: {d2.ColumnY}");
            //sb.AppendLine($"绕Z，Y，X轴旋转矩阵ColumnZ: {d2.ColumnZ}");
            //sb.AppendLine($"最终变换矩阵ColumnX: {fin.ColumnX}");
            //sb.Append($"最终变换矩阵ColumnY: {fin.ColumnY}");
            //sb.Append($"最终变换矩阵ColumnZ: {fin.ColumnZ}");
            //LogHelper.WriteLine(sb.ToString());
            return fin;
        }
        //public DVector3d Axis => DVector3d.FromXYZ(RotationAxis[0], RotationAxis[1], RotationAxis[2]);

        //[JsonProperty("Rotation axis")]
        //public List<double> RotationAxis { get; set; }

        //[JsonProperty("Rotation angle")]
        //public double Degrees { get; set; }
        public override string ToString()
        {
            return $"Name: {Name}, Transform: {Transform3d}";
        }
    }

    internal class RingData
    {
        [JsonProperty("models")]
        public List<RingInfo> Rings { get; set; }
    }

    internal class RingInfoReader
    {
        public static RingData Read(string filePath)
        {
            //var dir = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            //var filePath = Path.Combine(dir, "Pose.json");
            return JsonConvert.DeserializeObject<RingData>(File.ReadAllText(filePath));
            //return JsonConvert.DeserializeObject<RingData>(json); 
        }
    }
}