using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using BLEProtocol;

/// <summary>
/// OTA版本信息
/// </summary>
[Serializable]
public class OTAVersionInfo
{
    public uint FirmwareVersion;  // 固件版本 (4字节)
    public uint HardwareVersion;  // 硬件版本 (4字节)
    public uint OTAVersion;       // OTA版本 (4字节)

    public override string ToString()
    {
        return $"固件版本: {FirmwareVersion}, 硬件版本: {HardwareVersion}, OTA版本: {OTAVersion}";
    }
}

/// <summary>
/// OTA升级状态
/// </summary>
public enum OTAState
{
    Idle,               // 空闲
    QueryingVersion,    // 查询版本中
    Starting,           // 开始升级中
    Transferring,       // 传输数据中
    Ending,             // 结束传输中
    Cancelling,         // 取消升级中
    Completed,          // 完成
    Error               // 错误
}

/// <summary>
/// OTA升级管理器 - 处理固件OTA升级
/// </summary>
public class OTAManager : MonoBehaviour
{
    public static OTAManager Instance { get; private set; }

    // 事件定义
    public event Action<OTAVersionInfo> OnVersionInfoReceived;  // 收到版本信息
    public event Action<bool> OnStartUpgradeResult;             // 开始升级结果
    public event Action<int, int, int, int> OnTransferProgress; // 传输进度 (当前包, 总包数, 重试次数, 最大重试次数)
    public event Action<bool> OnTransferComplete;               // 传输完成
    public event Action<bool> OnCancelResult;                   // 取消结果
    public event Action<string> OnError;                        // 错误事件
    public event Action<OTAState> OnStateChanged;               // 状态变化

    // 状态
    public OTAState CurrentState { get; private set; } = OTAState.Idle;

    // 升级参数
    private byte[] _firmwareData;           // 固件数据
    private uint _firmwareVersion;          // 固件版本
    private int _currentPacketIndex;        // 当前包序号
    private int _totalPackets;              // 总包数
    private const int PACKET_SIZE = 512;    // 每包数据大小（根据设备MTU调整）

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }
    }

    #region OTA命令接口

    /// <summary>
    /// 查询OTA版本信息 (命令 0x80)
    /// </summary>
    public void QueryVersionInfo(Action<OTAVersionInfo> callback = null)
    {
        if (!CheckConnection()) return;

        SetState(OTAState.QueryingVersion);

        var frame = new BLEFrame
        {
            Header1 = BLEConstants.FRAME_HEADER_1,
            Header2 = BLEConstants.FRAME_HEADER_2,
            Command = BLEConstants.CMD_OTA_QUERY_VERSION,
            ReadWrite = BLEConstants.RW_READ,
            Length = 0,
            Data = null
        };

        SendFrame(frame, (response) =>
        {
            if (response.IsSuccess && response.Data != null && response.Data.Length >= 12)
            {
                var info = new OTAVersionInfo
                {
                    FirmwareVersion = BitConverter.ToUInt32(response.Data, 0),
                    HardwareVersion = BitConverter.ToUInt32(response.Data, 4),
                    OTAVersion = BitConverter.ToUInt32(response.Data, 8)
                };
                SetState(OTAState.Idle);
                OnVersionInfoReceived?.Invoke(info);
                callback?.Invoke(info);
            }
            else
            {
                SetState(OTAState.Error);
                OnError?.Invoke("查询OTA版本信息失败");
                callback?.Invoke(null);
            }
        });
    }

    /// <summary>
    /// 开始OTA升级 (命令 0x81)
    /// </summary>
    /// <param name="firmwareData">固件数据</param>
    /// <param name="firmwareVersion">固件版本</param>
    /// <param name="callback">回调</param>
    public void StartUpgrade(byte[] firmwareData, uint firmwareVersion, Action<bool> callback = null)
    {
        if (!CheckConnection())
        {
            callback?.Invoke(false);
            return;
        }

        if (firmwareData == null || firmwareData.Length == 0)
        {
            LogError("固件数据为空");
            callback?.Invoke(false);
            return;
        }

        _firmwareData = firmwareData;
        _firmwareVersion = firmwareVersion;
        _currentPacketIndex = 0;
        _totalPackets = (int)Math.Ceiling((double)firmwareData.Length / PACKET_SIZE);

        SetState(OTAState.Starting);

        // 计算CRC16
        ushort crc16 = CalculateCRC16(firmwareData);

        // 构建数据: 版本号(4) + 大小(4) + CRC16(2)
        byte[] data = new byte[10];
        BitConverter.GetBytes(firmwareVersion).CopyTo(data, 0);
        BitConverter.GetBytes((uint)firmwareData.Length).CopyTo(data, 4);
        BitConverter.GetBytes(crc16).CopyTo(data, 8);

        var frame = new BLEFrame
        {
            Header1 = BLEConstants.FRAME_HEADER_1,
            Header2 = BLEConstants.FRAME_HEADER_2,
            Command = BLEConstants.CMD_OTA_START,
            ReadWrite = BLEConstants.RW_WRITE,
            Length = (byte)data.Length,
            Data = data
        };

        // 使用协程来处理响应和延迟
        StartCoroutine(StartUpgradeCoroutineInternal(frame, callback));
    }

    private IEnumerator StartUpgradeCoroutineInternal(BLEFrame frame, Action<bool> callback)
    {
        BLEResponse response = new BLEResponse { Status = BLEConstants.STATUS_DEVICE_ERROR };
        bool completed = false;

        SendFrame(frame, (resp) =>
        {
            response = resp;
            completed = true;
        });

        yield return new WaitUntil(() => completed);

        bool success = response.IsSuccess;
        if (success)
        {
            // 检查连接状态，如果断开则等待重连
            int retryCount = 0;
            const int maxRetries = 10;
            while (BluetoothManager.Instance != null && !BluetoothManager.Instance.IsConnected && retryCount < maxRetries)
            {
                yield return new WaitForSeconds(0.5f);
                retryCount++;
            }
            
            if (BluetoothManager.Instance == null || !BluetoothManager.Instance.IsConnected)
            {
                SetState(OTAState.Error);
                OnStartUpgradeResult?.Invoke(false);
                callback?.Invoke(false);
                yield break;
            }
            
            // 实际测试连接是否可用 - 发送一个查询版本命令
            bool testCompleted = false;
            bool testSuccess = false;
            
            var testFrame = new BLEFrame
            {
                Header1 = BLEConstants.FRAME_HEADER_1,
                Header2 = BLEConstants.FRAME_HEADER_2,
                Command = BLEConstants.CMD_OTA_QUERY_VERSION,
                ReadWrite = BLEConstants.RW_READ,
                Length = 0,
                Data = null
            };
            
            SendFrame(testFrame, (testResponse) =>
            {
                testSuccess = testResponse.IsSuccess;
                testCompleted = true;
            });
            
            // 等待最多3秒
            float testStartTime = Time.time;
            while (!testCompleted && Time.time - testStartTime < 3f)
            {
                yield return null;
            }
            
            if (!testCompleted)
            {
                LogError("[OTA-DEBUG] 连接测试超时，BLE连接可能已断开");
                SetState(OTAState.Error);
                OnStartUpgradeResult?.Invoke(false);
                callback?.Invoke(false);
                yield break;
            }
            
            if (!testSuccess)
            {
                SetState(OTAState.Error);
                OnStartUpgradeResult?.Invoke(false);
                callback?.Invoke(false);
                yield break;
            }
            
            SetState(OTAState.Transferring);
            OnStartUpgradeResult?.Invoke(true);
            callback?.Invoke(true);
        }
        else
        {
            SetState(OTAState.Error);
            OnStartUpgradeResult?.Invoke(false);
            callback?.Invoke(false);
        }
    }

    /// <summary>
    /// 传输固件数据包 (命令 0x82)
    /// </summary>
    public IEnumerator TransferFirmware(Action<bool> callback = null)
    {
        if (_firmwareData == null)
        {
            LogError("没有固件数据");
            callback?.Invoke(false);
            yield break;
        }

        SetState(OTAState.Transferring);
        
        // 每包实际数据长度（不包括包序号）
        const int DATA_PER_PACKET = 253; // 255 - 2 (包序号)
        
        // 重新计算总包数
        _totalPackets = (_firmwareData.Length + DATA_PER_PACKET - 1) / DATA_PER_PACKET;

        for (int i = 0; i < _totalPackets; i++)
        {
            _currentPacketIndex = i;
            int offset = i * DATA_PER_PACKET;  // 使用实际数据长度计算偏移
            int length = Mathf.Min(DATA_PER_PACKET, _firmwareData.Length - offset);

            // 构建数据包: 包序号(2) + 数据(N)
            byte[] packetData = new byte[2 + length];
            BitConverter.GetBytes((ushort)i).CopyTo(packetData, 0);
            Buffer.BlockCopy(_firmwareData, offset, packetData, 2, length);

            var frame = new BLEFrame
            {
                Header1 = BLEConstants.FRAME_HEADER_1,
                Header2 = BLEConstants.FRAME_HEADER_2,
                Command = BLEConstants.CMD_OTA_TRANSFER_DATA,
                ReadWrite = BLEConstants.RW_WRITE,
                Length = (byte)packetData.Length,
                Data = packetData
            };

            // 发送数据包，带重试机制
            bool packetSuccess = false;
            int retryCount = 0;
            const int maxRetries = 5;
            
            while (!packetSuccess && retryCount < maxRetries)
            {
                if (retryCount > 0)
                {
                    OnTransferProgress?.Invoke(i + 1, _totalPackets, retryCount, maxRetries);
                    yield return new WaitForSeconds(0.5f);
                }
                
                yield return SendFrameCoroutine(frame, (response) =>
                {
                    packetSuccess = response.IsSuccess;
                });
                
                if (!packetSuccess)
                {
                    retryCount++;
                }
            }

            if (!packetSuccess)
            {
                SetState(OTAState.Error);
                OnError?.Invoke($"传输包 {_currentPacketIndex} 失败");
                callback?.Invoke(false);
                yield break;
            }

            // 报告进度（无重试）
            OnTransferProgress?.Invoke(i + 1, _totalPackets, 0, 0);

            // 每包之间添加小延迟，避免设备处理不过来
            if (i < _totalPackets - 1)
            {
                yield return new WaitForSeconds(0.01f);
            }
        }

        SetState(OTAState.Ending);
        OnTransferComplete?.Invoke(true);
        callback?.Invoke(true);
    }

    /// <summary>
    /// 结束传输 (命令 0x83)
    /// </summary>
    public void EndTransfer(Action<bool> callback = null)
    {
        if (!CheckConnection())
        {
            callback?.Invoke(false);
            return;
        }

        SetState(OTAState.Ending);

        // 数据: 总大小(4) + CRC16(2)
        byte[] data = new byte[6];
        BitConverter.GetBytes((uint)_firmwareData.Length).CopyTo(data, 0);
        ushort crc16 = CalculateCRC16(_firmwareData);
        BitConverter.GetBytes(crc16).CopyTo(data, 4);

        var frame = new BLEFrame
        {
            Header1 = BLEConstants.FRAME_HEADER_1,
            Header2 = BLEConstants.FRAME_HEADER_2,
            Command = BLEConstants.CMD_OTA_END_TRANSFER,
            ReadWrite = BLEConstants.RW_WRITE,
            Length = (byte)data.Length,
            Data = data
        };

        SendFrame(frame, (response) =>
        {
            bool success = response.IsSuccess;
            if (success)
            {
                SetState(OTAState.Completed);
            }
            else
            {
                SetState(OTAState.Error);
            }
            callback?.Invoke(success);
        });
    }

    /// <summary>
    /// 取消升级 (命令 0x85)
    /// </summary>
    public void CancelUpgrade(Action<bool> callback = null)
    {
        if (!CheckConnection())
        {
            callback?.Invoke(false);
            return;
        }

        SetState(OTAState.Cancelling);

        // 数据: 取消标志(1)
        byte[] data = new byte[] { 0x01 };

        var frame = new BLEFrame
        {
            Header1 = BLEConstants.FRAME_HEADER_1,
            Header2 = BLEConstants.FRAME_HEADER_2,
            Command = BLEConstants.CMD_OTA_CANCEL,
            ReadWrite = BLEConstants.RW_WRITE,
            Length = (byte)data.Length,
            Data = data
        };

        SendFrame(frame, (response) =>
        {
            bool success = response.IsSuccess;
            if (success)
            {
                SetState(OTAState.Idle);
                _firmwareData = null;
            }
            else
            {
                SetState(OTAState.Error);
            }
            OnCancelResult?.Invoke(success);
            callback?.Invoke(success);
        });
    }

    #endregion

    #region 完整升级流程

    /// <summary>
    /// 执行完整OTA升级流程
    /// </summary>
    public IEnumerator PerformFullUpgrade(byte[] firmwareData, uint firmwareVersion, Action<bool> callback = null)
    {
        // 0. 先取消可能存在的未完成升级
        bool cancelSuccess = false;
        yield return CancelUpgradeCoroutine((success) => cancelSuccess = success);
        if (cancelSuccess)
        {
            yield return new WaitForSeconds(1f);
        }

        // 1. 查询版本信息
        OTAVersionInfo versionInfo = null;
        yield return QueryVersionInfoCoroutine((info) => versionInfo = info);

        if (versionInfo == null)
        {
            callback?.Invoke(false);
            yield break;
        }

        // 2. 开始升级
        bool startSuccess = false;
        yield return StartUpgradeCoroutine(firmwareData, firmwareVersion, (success) => startSuccess = success);

        if (!startSuccess)
        {
            callback?.Invoke(false);
            yield break;
        }

        // 3. 传输数据
        bool transferSuccess = false;
        yield return TransferFirmware((success) => transferSuccess = success);

        if (!transferSuccess)
        {
            callback?.Invoke(false);
            yield break;
        }

        // 4. 结束传输
        bool endSuccess = false;
        yield return EndTransferCoroutine((success) => endSuccess = success);

        if (!endSuccess)
        {
            callback?.Invoke(false);
            yield break;
        }

        callback?.Invoke(true);
    }

    #endregion

    #region 辅助方法

    private bool CheckConnection()
    {
        if (BLECommunicationManager.Instance == null) return false;
        if (BluetoothManager.Instance == null || !BluetoothManager.Instance.IsConnected) return false;
        return true;
    }

    private void SetState(OTAState newState)
    {
        if (CurrentState != newState)
        {
            CurrentState = newState;
            OnStateChanged?.Invoke(newState);
        }
    }

    private void SendFrame(BLEFrame frame, Action<BLEResponse> callback)
    {
        BLECommunicationManager.Instance.SendFrameInternal(frame, callback);
    }

    private IEnumerator SendFrameCoroutine(BLEFrame frame, Action<BLEResponse> callback)
    {
        bool completed = false;
        BLEResponse response = new BLEResponse { Status = BLEConstants.STATUS_DEVICE_ERROR };

        SendFrame(frame, (resp) =>
        {
            response = resp;
            completed = true;
        });

        yield return new WaitUntil(() => completed);
        callback?.Invoke(response);
    }

    private IEnumerator QueryVersionInfoCoroutine(Action<OTAVersionInfo> callback)
    {
        OTAVersionInfo info = null;
        QueryVersionInfo((result) => info = result);
        yield return new WaitUntil(() => CurrentState != OTAState.QueryingVersion || info != null);
        callback?.Invoke(info);
    }

    private IEnumerator StartUpgradeCoroutine(byte[] firmwareData, uint firmwareVersion, Action<bool> callback)
    {
        bool completed = false;
        bool success = false;

        StartUpgrade(firmwareData, firmwareVersion, (result) =>
        {
            success = result;
            completed = true;
        });

        yield return new WaitUntil(() => completed);
        callback?.Invoke(success);
    }

    private IEnumerator CancelUpgradeCoroutine(Action<bool> callback)
    {
        bool completed = false;
        bool success = false;

        CancelUpgrade((result) =>
        {
            success = result;
            completed = true;
        });

        yield return new WaitUntil(() => completed);
        callback?.Invoke(success);
    }

    private IEnumerator EndTransferCoroutine(Action<bool> callback)
    {
        bool completed = false;
        bool success = false;

        EndTransfer((result) =>
        {
            success = result;
            completed = true;
        });

        yield return new WaitUntil(() => completed);
        callback?.Invoke(success);
    }

    /// <summary>
    /// 计算CRC16校验
    /// </summary>
    private ushort CalculateCRC16(byte[] data)
    {
        ushort crc = 0xFFFF;
        for (int i = 0; i < data.Length; i++)
        {
            crc ^= (ushort)(data[i] << 8);
            for (int j = 0; j < 8; j++)
            {
                if ((crc & 0x8000) != 0)
                    crc = (ushort)((crc << 1) ^ 0x1021);
                else
                    crc <<= 1;
            }
        }
        return crc;
    }

    private void Log(string message)
    {
        Debug.Log($"[OTAManager] {message}");
    }

    private void LogError(string message)
    {
        Debug.LogError($"[OTAManager] {message}");
    }

    #endregion
}