using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text.Json;
using Microsoft.Win32;

var options = CliOptions.Parse(args);
if (!options.HasReferenceCenter && (string.IsNullOrWhiteSpace(options.ReferenceDwgPath) || !File.Exists(options.ReferenceDwgPath)))
    throw new FileNotFoundException($"参考 DWG 不存在: {options.ReferenceDwgPath}");
if (string.IsNullOrWhiteSpace(options.StudentDwgPath) || !File.Exists(options.StudentDwgPath))
    throw new FileNotFoundException($"学生 DWG 不存在: {options.StudentDwgPath}");
if (string.IsNullOrWhiteSpace(options.OutputDwgPath))
    throw new ArgumentException("缺少 --output-dwg。为避免破坏原始学生图，必须输出到副本。");

Directory.CreateDirectory(Path.GetDirectoryName(options.OutputDwgPath) ?? Environment.CurrentDirectory);
var result = StaRunner.Run(() => DwgSheetFrameAligner.Align(options));
var reportPath = Path.Combine(
    Path.GetDirectoryName(options.OutputDwgPath) ?? Environment.CurrentDirectory,
    Path.GetFileNameWithoutExtension(options.OutputDwgPath) + ".align-report.json");
File.WriteAllText(reportPath, JsonSerializer.Serialize(result, JsonDefaults.Options));
Console.WriteLine(JsonSerializer.Serialize(result, JsonDefaults.Options));

sealed class DwgSheetFrameAligner
{
    const double AxisTolerance = 0.05;
    const double FrameTolerance = 1.0;

    [DllImport("ole32.dll", CharSet = CharSet.Unicode)]
    private static extern int CLSIDFromProgID(string progId, out Guid clsid);

    [DllImport("oleaut32.dll", PreserveSig = false)]
    [return: MarshalAs(UnmanagedType.IUnknown)]
    private static extern object GetActiveObject(ref Guid clsid, IntPtr reserved);

    public static AlignResult Align(CliOptions options)
    {
        var started = DateTimeOffset.Now;
        var app = ConnectOrCreate(options.ProgId, options.Visible, out _);
        object? referenceDoc = null;
        object? studentDoc = null;
        try
        {
            FrameRect referenceFrame;
            if (options.HasReferenceCenter)
            {
                referenceFrame = FrameRect.FromCenter(options.ReferenceCenterX!.Value, options.ReferenceCenterY!.Value);
            }
            else
            {
                WaitForQuiescent(app, TimeSpan.FromSeconds(30));
                referenceDoc = OpenDocument(app, options.ReferenceDwgPath, readOnly: true);
                referenceFrame = DetectInnerFrame(referenceDoc);
                TryInvoke(referenceDoc, "Close", [false]);
                ReleaseCom(referenceDoc);
                referenceDoc = null;
            }

            File.Copy(options.StudentDwgPath, options.OutputDwgPath, overwrite: true);
            WaitForQuiescent(app, TimeSpan.FromSeconds(30));
            studentDoc = OpenDocument(app, options.OutputDwgPath, readOnly: false);
            var studentFrameBefore = DetectInnerFrame(studentDoc);

            var dx = referenceFrame.CenterX - studentFrameBefore.CenterX;
            var dy = referenceFrame.CenterY - studentFrameBefore.CenterY;
            var moved = MoveAllEntities(studentDoc, dx, dy);
            TryInvoke(studentDoc, "Save", []);

            var studentFrameAfter = DetectInnerFrame(studentDoc);
            if (options.CloseAfterAlign)
                TryInvoke(studentDoc, "Close", [false]);

            return new AlignResult
            {
                Ok = true,
                StartedAt = started,
                CompletedAt = DateTimeOffset.Now,
                ReferenceDwgPath = options.ReferenceDwgPath,
                StudentDwgPath = options.StudentDwgPath,
                OutputDwgPath = options.OutputDwgPath,
                ReferenceInnerFrame = referenceFrame,
                StudentInnerFrameBefore = studentFrameBefore,
                StudentInnerFrameAfter = studentFrameAfter,
                DeltaX = dx,
                DeltaY = dy,
                MovedEntityCount = moved,
                Message = "已按图框内圈中心整体平移学生 DWG 副本。"
            };
        }
        finally
        {
            if (referenceDoc != null)
            {
                TryInvoke(referenceDoc, "Close", [false]);
                ReleaseCom(referenceDoc);
            }
            if (studentDoc != null)
                ReleaseCom(studentDoc);
            ReleaseCom(app);
        }
    }

    static FrameRect DetectInnerFrame(object doc)
    {
        var lines = new List<Line2d>();
        lines.AddRange(ReadLines(doc, "ModelSpace"));
        lines.AddRange(ReadLines(doc, "PaperSpace"));
        if (lines.Count == 0)
            throw new InvalidOperationException("DWG 中没有可用于识别图框的直线。");

        var horizontal = lines
            .Where(line => Math.Abs(line.Y1 - line.Y2) <= AxisTolerance)
            .Select(line => line.Normalized())
            .ToList();
        var vertical = lines
            .Where(line => Math.Abs(line.X1 - line.X2) <= AxisTolerance)
            .Select(line => line.Normalized())
            .ToList();

        var maxHorizontal = horizontal.Select(line => line.Length).DefaultIfEmpty(0).Max();
        var maxVertical = vertical.Select(line => line.Length).DefaultIfEmpty(0).Max();
        var longHorizontal = horizontal
            .Where(line => line.Length >= maxHorizontal * 0.65)
            .OrderByDescending(line => line.Length)
            .Take(20)
            .ToList();
        var longVertical = vertical
            .Where(line => line.Length >= maxVertical * 0.65)
            .OrderByDescending(line => line.Length)
            .Take(20)
            .ToList();

        var rectangles = new List<FrameRect>();
        for (var hi = 0; hi < longHorizontal.Count; hi++)
        {
            for (var hj = hi + 1; hj < longHorizontal.Count; hj++)
            {
                var bottom = longHorizontal[hi].Y1 <= longHorizontal[hj].Y1 ? longHorizontal[hi] : longHorizontal[hj];
                var top = ReferenceEquals(bottom, longHorizontal[hi]) ? longHorizontal[hj] : longHorizontal[hi];
                for (var vi = 0; vi < longVertical.Count; vi++)
                {
                    for (var vj = vi + 1; vj < longVertical.Count; vj++)
                    {
                        var left = longVertical[vi].X1 <= longVertical[vj].X1 ? longVertical[vi] : longVertical[vj];
                        var right = ReferenceEquals(left, longVertical[vi]) ? longVertical[vj] : longVertical[vi];
                        if (!SpansX(bottom, left.X1, right.X1) || !SpansX(top, left.X1, right.X1))
                            continue;
                        if (!SpansY(left, bottom.Y1, top.Y1) || !SpansY(right, bottom.Y1, top.Y1))
                            continue;

                        rectangles.Add(new FrameRect
                        {
                            MinX = left.X1,
                            MinY = bottom.Y1,
                            MaxX = right.X1,
                            MaxY = top.Y1,
                            SourceHandles =
                            [
                                bottom.Handle,
                                top.Handle,
                                left.Handle,
                                right.Handle
                            ]
                        });
                    }
                }
            }
        }

        var unique = rectangles
            .GroupBy(rect => $"{Math.Round(rect.MinX, 3)}|{Math.Round(rect.MinY, 3)}|{Math.Round(rect.MaxX, 3)}|{Math.Round(rect.MaxY, 3)}")
            .Select(group => group.First())
            .Where(rect => rect.Width > 0 && rect.Height > 0)
            .OrderByDescending(rect => rect.Area)
            .ToList();

        if (unique.Count == 0)
            throw new InvalidOperationException("未能识别图框矩形。");

        // 工程图一般有外框和内框；面积最大的是外框，第二大的是内框。
        return unique.Count >= 2 ? unique[1] : unique[0];
    }

    static bool SpansX(Line2d line, double left, double right) =>
        line.MinX <= left + FrameTolerance && line.MaxX >= right - FrameTolerance;

    static bool SpansY(Line2d line, double bottom, double top) =>
        line.MinY <= bottom + FrameTolerance && line.MaxY >= top - FrameTolerance;

    static List<Line2d> ReadLines(object doc, string spaceName)
    {
        var result = new List<Line2d>();
        var space = GetProperty(doc, spaceName);
        if (space == null)
            return result;

        try
        {
            var count = ToInt(GetProperty(space, "Count")) ?? 0;
            for (var i = 0; i < count; i++)
            {
                var entity = GetCollectionItem(space, i);
                if (entity == null)
                    continue;
                try
                {
                    var objectName = ReadString(entity, "ObjectName");
                    if (!string.Equals(objectName, "AcDbLine", StringComparison.OrdinalIgnoreCase))
                        continue;

                    var start = DoubleList(GetProperty(entity, "StartPoint"));
                    var end = DoubleList(GetProperty(entity, "EndPoint"));
                    if (start.Count < 2 || end.Count < 2)
                        continue;

                    result.Add(new Line2d(
                        start[0],
                        start[1],
                        end[0],
                        end[1],
                        ReadString(entity, "Handle"),
                        spaceName));
                }
                finally
                {
                    ReleaseCom(entity);
                }
            }
        }
        finally
        {
            ReleaseCom(space);
        }

        return result;
    }

    static int MoveAllEntities(object doc, double dx, double dy)
    {
        var moved = 0;
        moved += MoveSpaceEntities(doc, "ModelSpace", dx, dy);
        moved += MoveSpaceEntities(doc, "PaperSpace", dx, dy);
        return moved;
    }

    static int MoveSpaceEntities(object doc, string spaceName, double dx, double dy)
    {
        var moved = 0;
        var space = GetProperty(doc, spaceName);
        if (space == null)
            return moved;

        try
        {
            var count = ToInt(GetProperty(space, "Count")) ?? 0;
            var from = new double[] { 0, 0, 0 };
            var to = new double[] { dx, dy, 0 };
            for (var i = 0; i < count; i++)
            {
                var entity = GetCollectionItem(space, i);
                if (entity == null)
                    continue;
                try
                {
                    TryInvoke(entity, "Move", [from, to]);
                    moved++;
                }
                finally
                {
                    ReleaseCom(entity);
                }
            }
        }
        finally
        {
            ReleaseCom(space);
        }

        return moved;
    }

    static object ConnectOrCreate(string progId, bool visible, out DateTimeOffset started)
    {
        started = DateTimeOffset.Now;
        object? app = null;
        try
        {
            var type = Type.GetTypeFromProgID(progId);
            if (type != null)
                app = GetActiveObjectFromProgId(progId);
        }
        catch
        {
            app = null;
        }

        if (app == null)
        {
            StartAutoCadFromRegistry(progId);
            var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(60);
            while (DateTime.UtcNow < deadline && app == null)
            {
                try { app = GetActiveObjectFromProgId(progId); }
                catch { Thread.Sleep(500); }
            }
        }

        if (app == null)
            throw new InvalidOperationException($"AutoCAD 启动或 COM 连接失败: {progId}");

        TrySetProperty(app, "Visible", visible);
        return app;
    }

    static object GetActiveObjectFromProgId(string progId)
    {
        var hr = CLSIDFromProgID(progId, out var clsid);
        if (hr < 0)
            Marshal.ThrowExceptionForHR(hr);
        return GetActiveObject(ref clsid, IntPtr.Zero);
    }

    static void StartAutoCadFromRegistry(string progId)
    {
        var clsid = ReadDefaultValue($@"{progId}\CLSID");
        var command = string.IsNullOrWhiteSpace(clsid) ? "" : ReadDefaultValue($@"CLSID\{clsid}\LocalServer32");
        var exe = ExtractExePath(command);
        if (string.IsNullOrWhiteSpace(exe) || !File.Exists(exe))
            exe = @"D:\Program Files\Autodesk\AutoCAD 2020\acad.exe";
        if (!File.Exists(exe))
            throw new FileNotFoundException($"找不到 acad.exe。ProgID={progId}, LocalServer32={command}");

        Process.Start(new ProcessStartInfo
        {
            FileName = exe,
            Arguments = "/Automation",
            UseShellExecute = true,
            WorkingDirectory = Path.GetDirectoryName(exe) ?? Environment.CurrentDirectory
        });
    }

    static string ReadDefaultValue(string subKey)
    {
        using var key = Registry.ClassesRoot.OpenSubKey(subKey);
        return key?.GetValue("")?.ToString() ?? "";
    }

    static string ExtractExePath(string command)
    {
        if (string.IsNullOrWhiteSpace(command))
            return "";
        var trimmed = command.Trim();
        if (trimmed.StartsWith('"'))
        {
            var end = trimmed.IndexOf('"', 1);
            return end > 1 ? trimmed[1..end] : "";
        }
        var exeIndex = trimmed.IndexOf(".exe", StringComparison.OrdinalIgnoreCase);
        return exeIndex >= 0 ? trimmed[..(exeIndex + 4)] : trimmed;
    }

    static object OpenDocument(object app, string drawingPath, bool readOnly)
    {
        var documents = GetProperty(app, "Documents") ?? throw new InvalidOperationException("AutoCAD.Application.Documents 不可用。");
        try
        {
            return TryInvoke(documents, "Open", [drawingPath, readOnly])
                ?? TryInvoke(documents, "Open", [drawingPath])
                ?? throw new InvalidOperationException($"AutoCAD 打开 DWG 失败: {drawingPath}");
        }
        finally
        {
            ReleaseCom(documents);
        }
    }

    static void WaitForQuiescent(object app, TimeSpan timeout)
    {
        var deadline = DateTime.UtcNow + timeout;
        while (DateTime.UtcNow < deadline)
        {
            var state = TryInvoke(app, "GetAcadState", []);
            if (state == null)
                return;
            try
            {
                if (ToBool(GetProperty(state, "IsQuiescent")) ?? true)
                    return;
            }
            finally
            {
                ReleaseCom(state);
            }
            Thread.Sleep(250);
        }
    }

    static object? GetProperty(object obj, string name) => RetryCom(() =>
    {
        try
        {
            return obj.GetType().InvokeMember(name, BindingFlags.GetProperty, null, obj, null, CultureInfo.InvariantCulture);
        }
        catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException)) { throw; }
        catch (COMException ex) when (IsRetryableCom(ex)) { throw; }
        catch { return null; }
    });

    static object? GetCollectionItem(object obj, int index) => RetryCom(() =>
    {
        foreach (var flags in new[] { BindingFlags.GetProperty, BindingFlags.InvokeMethod })
        {
            try { return obj.GetType().InvokeMember("Item", flags, null, obj, [index], CultureInfo.InvariantCulture); }
            catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException)) { throw; }
            catch (COMException ex) when (IsRetryableCom(ex)) { throw; }
            catch { }
        }
        return null;
    });

    static object? TryInvoke(object obj, string name, object?[] args) => RetryCom(() =>
    {
        try { return obj.GetType().InvokeMember(name, BindingFlags.InvokeMethod, null, obj, args, CultureInfo.InvariantCulture); }
        catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException)) { throw; }
        catch (COMException ex) when (IsRetryableCom(ex)) { throw; }
        catch { return null; }
    });

    static void TrySetProperty(object obj, string name, object? value)
    {
        RetryCom(() =>
        {
            try { obj.GetType().InvokeMember(name, BindingFlags.SetProperty, null, obj, [value], CultureInfo.InvariantCulture); }
            catch { }
            return null;
        });
    }

    static object? RetryCom(Func<object?> action)
    {
        Exception? last = null;
        for (var i = 0; i < 180; i++)
        {
            try { return action(); }
            catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
            {
                last = ex.InnerException;
                Thread.Sleep(100);
            }
            catch (COMException ex) when (IsRetryableCom(ex))
            {
                last = ex;
                Thread.Sleep(100);
            }
        }
        if (last != null)
            throw last;
        return action();
    }

    static bool IsRetryableCom(Exception? ex) =>
        ex is COMException com && unchecked((uint)com.HResult) is 0x80010001 or 0x8001010A;

    static string ReadString(object obj, string name) => Convert.ToString(GetProperty(obj, name), CultureInfo.InvariantCulture) ?? "";

    static int? ToInt(object? value)
    {
        if (value == null)
            return null;
        return int.TryParse(Convert.ToString(value, CultureInfo.InvariantCulture), NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsed)
            ? parsed
            : null;
    }

    static bool? ToBool(object? value)
    {
        if (value == null)
            return null;
        if (value is bool b)
            return b;
        return bool.TryParse(Convert.ToString(value, CultureInfo.InvariantCulture), out var parsed) ? parsed : null;
    }

    static List<double> DoubleList(object? value)
    {
        if (value == null)
            return [];
        if (value is double[] doubles)
            return doubles.ToList();
        if (value is object[] objects)
            return objects.SelectMany(DoubleList).ToList();
        if (value is Array array)
        {
            var result = new List<double>();
            foreach (var item in array)
            {
                if (double.TryParse(Convert.ToString(item, CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture, out var parsed))
                    result.Add(parsed);
            }
            return result;
        }
        return [];
    }

    static void ReleaseCom(object? obj)
    {
        if (obj != null && Marshal.IsComObject(obj))
            Marshal.ReleaseComObject(obj);
    }
}

sealed class CliOptions
{
    public string ReferenceDwgPath { get; set; } = "";
    public string StudentDwgPath { get; set; } = "";
    public string OutputDwgPath { get; set; } = "";
    public string ProgId { get; set; } = "AutoCAD.Application.23.1";
    public double? ReferenceCenterX { get; set; }
    public double? ReferenceCenterY { get; set; }
    public bool HasReferenceCenter => ReferenceCenterX != null && ReferenceCenterY != null;
    public bool Visible { get; set; } = true;
    public bool CloseAfterAlign { get; set; } = true;

    public static CliOptions Parse(string[] args)
    {
        var options = new CliOptions();
        for (var i = 0; i < args.Length; i++)
        {
            var key = args[i];
            var value = i + 1 < args.Length ? args[i + 1] : "";
            switch (key)
            {
                case "--reference-dwg":
                    options.ReferenceDwgPath = Path.GetFullPath(value.Trim().Trim('"'));
                    i++;
                    break;
                case "--student-dwg":
                    options.StudentDwgPath = Path.GetFullPath(value.Trim().Trim('"'));
                    i++;
                    break;
                case "--output-dwg":
                    options.OutputDwgPath = Path.GetFullPath(value.Trim().Trim('"'));
                    i++;
                    break;
                case "--reference-center-x":
                    options.ReferenceCenterX = double.Parse(value, CultureInfo.InvariantCulture);
                    i++;
                    break;
                case "--reference-center-y":
                    options.ReferenceCenterY = double.Parse(value, CultureInfo.InvariantCulture);
                    i++;
                    break;
                case "--prog-id":
                    options.ProgId = value;
                    i++;
                    break;
                case "--visible":
                    options.Visible = bool.TryParse(value, out var visible) ? visible : options.Visible;
                    i++;
                    break;
                case "--close-after-align":
                    options.CloseAfterAlign = bool.TryParse(value, out var close) ? close : options.CloseAfterAlign;
                    i++;
                    break;
            }
        }
        return options;
    }
}

sealed record Line2d(double X1, double Y1, double X2, double Y2, string Handle, string SpaceName)
{
    public double Length => Math.Sqrt(Math.Pow(X2 - X1, 2) + Math.Pow(Y2 - Y1, 2));
    public double MinX => Math.Min(X1, X2);
    public double MaxX => Math.Max(X1, X2);
    public double MinY => Math.Min(Y1, Y2);
    public double MaxY => Math.Max(Y1, Y2);

    public Line2d Normalized()
    {
        if (Math.Abs(Y1 - Y2) <= Math.Abs(X1 - X2))
            return X1 <= X2 ? this : this with { X1 = X2, Y1 = Y2, X2 = X1, Y2 = Y1 };
        return Y1 <= Y2 ? this : this with { X1 = X2, Y1 = Y2, X2 = X1, Y2 = Y1 };
    }
}

sealed class FrameRect
{
    public double MinX { get; set; }
    public double MinY { get; set; }
    public double MaxX { get; set; }
    public double MaxY { get; set; }
    public double Width => MaxX - MinX;
    public double Height => MaxY - MinY;
    public double Area => Width * Height;
    public double CenterX => (MinX + MaxX) / 2.0;
    public double CenterY => (MinY + MaxY) / 2.0;
    public List<string> SourceHandles { get; set; } = [];

    public static FrameRect FromCenter(double x, double y)
    {
        return new FrameRect
        {
            MinX = x,
            MaxX = x,
            MinY = y,
            MaxY = y,
            SourceHandles = ["explicit_reference_center"]
        };
    }
}

sealed class AlignResult
{
    public bool Ok { get; set; }
    public DateTimeOffset StartedAt { get; set; }
    public DateTimeOffset CompletedAt { get; set; }
    public string ReferenceDwgPath { get; set; } = "";
    public string StudentDwgPath { get; set; } = "";
    public string OutputDwgPath { get; set; } = "";
    public FrameRect ReferenceInnerFrame { get; set; } = new();
    public FrameRect StudentInnerFrameBefore { get; set; } = new();
    public FrameRect StudentInnerFrameAfter { get; set; } = new();
    public double DeltaX { get; set; }
    public double DeltaY { get; set; }
    public int MovedEntityCount { get; set; }
    public string Message { get; set; } = "";
}

static class StaRunner
{
    public static T Run<T>(Func<T> action)
    {
        T? result = default;
        Exception? error = null;
        var thread = new Thread(() =>
        {
            try { result = action(); }
            catch (Exception ex) { error = ex; }
        });
        thread.SetApartmentState(ApartmentState.STA);
        thread.Start();
        thread.Join();
        if (error != null)
            throw error;
        return result!;
    }
}

static class JsonDefaults
{
    public static readonly JsonSerializerOptions Options = new()
    {
        WriteIndented = true,
        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower
    };
}