using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using SimpleCore;
using SimpleCore.Library;

namespace StandardScene.Charge
{
    /// <summary>
    /// 充电桩管理辅助类
    /// 提供简化的静态方法用于快速访问充电桩功能
    /// </summary>
    public static class ChargeStationHelper
    {
        private static ChargeStationManagementForm _managementForm;

        /// <summary>
        /// 打开充电桩管理窗口（单例模式）
        /// </summary>
        public static void OpenManagementWindow()
        {
            if (_managementForm == null || _managementForm.IsDisposed)
            {
                _managementForm = new ChargeStationManagementForm();
                _managementForm.FormClosed += (s, e) => _managementForm = null;
                _managementForm.Show();
            }
            else
            {
                _managementForm.BringToFront();
                _managementForm.Activate();
            }
        }

        /// <summary>
        /// 打开充电桩管理窗口（对话框模式）
        /// </summary>
        public static DialogResult OpenManagementDialog()
        {
            using (var form = new ChargeStationManagementForm())
            {
                return form.ShowDialog();
            }
        }

        /// <summary>
        /// 获取指定站点的充电桩
        /// </summary>
        /// <param name="siteId">站点ID</param>
        /// <returns>充电桩对象，如果不存在则返回null</returns>
        public static ChargeStation GetStationBySiteId(int siteId)
        {
            var dataService = ChargeStationDataService.Instance;
            return dataService.GetAllStations()
                .FirstOrDefault(s => s.SiteId == siteId);
        }

        /// <summary>
        /// 获取指定IP的充电桩
        /// </summary>
        /// <param name="ipAddress">IP地址</param>
        /// <returns>充电桩对象，如果不存在则返回null</returns>
        public static ChargeStation GetStationByIp(string ipAddress)
        {
            var dataService = ChargeStationDataService.Instance;
            return dataService.GetAllStations()
                .FirstOrDefault(s => s.IpAddress == ipAddress);
        }

        /// <summary>
        /// 获取所有充电桩配置
        /// </summary>
        /// <returns>所有充电桩配置列表</returns>
        public static List<ChargeStation> GetAllStationConfigs()
        {
            var dataService = ChargeStationDataService.Instance;
            return dataService.GetAllStations();
        }

        /// <summary>
        /// 获取当前充电策略配置
        /// </summary>
        /// <returns>充电策略配置对象</returns>
        public static ChargeStrategyConfig GetChargeStrategyConfig()
        {
            var configService = ChargeStrategyConfigService.Instance;
            return configService.LoadConfig();
        }

        /// <summary>
        /// 保存充电策略配置
        /// </summary>
        /// <param name="config">充电策略配置对象</param>
        public static void SaveChargeStrategyConfig(ChargeStrategyConfig config)
        {
            var configService = ChargeStrategyConfigService.Instance;
            configService.SaveConfig(config);
        }

        /// <summary>
        /// 检查指定站点是否有可用的充电桩
        /// </summary>
        /// <param name="siteId">站点ID</param>
        /// <returns>true表示有可用充电桩，false表示没有</returns>
        public static bool IsSiteHasAvailableChargeStation(int siteId)
        {
            var station = GetStationBySiteId(siteId);
            return station != null && 
                   station.Enabled && 
                   station.Status == ChargeStationStatus.Idle;
        }

        /// <summary>
        /// 标记充电桩开始充电
        /// </summary>
        /// <param name="stationId">充电桩编号</param>
        /// <param name="carId">车辆ID</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool StartCharging(string stationId, int carId)
        {
            try
            {
                var dataService = ChargeStationDataService.Instance;
                var station = dataService.GetStationById(stationId);

                if (station == null)
                {
                    Diagnosis.Log($"充电桩 {stationId} 不存在", "ChargeStation", true);
                    return false;
                }

                if (station.Status == ChargeStationStatus.Charging)
                {
                    Diagnosis.Log($"充电桩 {station.Name} 已经在充电中", "ChargeStation", true);
                    return false;
                }

                bool success = dataService.UpdateStationStatus(stationId, ChargeStationStatus.Charging);

                if (success)
                {
                    Diagnosis.Log($"车辆 {carId} 开始在充电桩 {station.Name} 充电", "ChargeStation", true);
                }

                return success;
            }
            catch (Exception ex)
            {
                Diagnosis.Log($"启动充电失败: {ExceptionFormatter.FormatEx(ex)}", "ChargeStation", true);
                return false;
            }
        }

        /// <summary>
        /// 标记充电桩停止充电
        /// </summary>
        /// <param name="stationId">充电桩编号</param>
        /// <param name="carId">车辆ID</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool StopCharging(string stationId, int carId)
        {
            try
            {
                var dataService = ChargeStationDataService.Instance;
                var station = dataService.GetStationById(stationId);

                if (station == null)
                {
                    Diagnosis.Log($"充电桩 {stationId} 不存在", "ChargeStation", true);
                    return false;
                }

                bool success = dataService.UpdateStationStatus(stationId, ChargeStationStatus.Idle);

                if (success)
                {
                    Diagnosis.Log($"车辆 {carId} 在充电桩 {station.Name} 充电完成", "ChargeStation", true);
                }

                return success;
            }
            catch (Exception ex)
            {
                Diagnosis.Log($"停止充电失败: {ExceptionFormatter.FormatEx(ex)}", "ChargeStation", true);
                return false;
            }
        }

        /// <summary>
        /// 标记充电桩为故障状态
        /// </summary>
        /// <param name="stationId">充电桩编号</param>
        /// <param name="reason">故障原因</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool MarkAsFault(string stationId, string reason = "")
        {
            try
            {
                var dataService = ChargeStationDataService.Instance;
                bool success = dataService.UpdateStationStatus(stationId, ChargeStationStatus.Fault);

                if (success)
                {
                    var station = dataService.GetStationById(stationId);
                    var message = string.IsNullOrEmpty(reason) 
                        ? $"充电桩 {station.Name} 标记为故障" 
                        : $"充电桩 {station.Name} 标记为故障: {reason}";
                    
                    Diagnosis.Log(message, "ChargeStation", true);
                }

                return success;
            }
            catch (Exception ex)
            {
                Diagnosis.Log($"标记故障失败: {ExceptionFormatter.FormatEx(ex)}", "ChargeStation", true);
                return false;
            }
        }

        /// <summary>
        /// 获取充电桩状态摘要信息
        /// </summary>
        /// <returns>格式化的状态字符串</returns>
        public static string GetStatusSummary()
        {
            var dataService = ChargeStationDataService.Instance;
            var stations = dataService.GetAllStations();

            var total = stations.Count;
            var idle = stations.Count(s => s.Status == ChargeStationStatus.Idle && s.Enabled);
            var charging = stations.Count(s => s.Status == ChargeStationStatus.Charging);
            var fault = stations.Count(s => s.Status == ChargeStationStatus.Fault);
            var offline = stations.Count(s => s.Status == ChargeStationStatus.Battery);

            return $"总数:{total} | 空闲:{idle} | 充电中:{charging} | 故障:{fault} | 离线:{offline}";
        }

        /// <summary>
        /// 获取最近的空闲充电桩（基于站点ID）
        /// </summary>
        /// <param name="currentSiteId">当前站点ID</param>
        /// <returns>最近的充电桩，如果没有则返回null</returns>
        public static ChargeStation FindNearestIdleStation(int currentSiteId)
        {
            var dataService = ChargeStationDataService.Instance;
            var idleStations = dataService.GetIdleStations();

            if (idleStations.Count == 0)
                return null;

            // 优先选择同站点的充电桩
            var sameStation = idleStations.FirstOrDefault(s => s.SiteId == currentSiteId);
            if (sameStation != null)
                return sameStation;

            // 否则选择第一个可用的
            return idleStations[0];
        }

        /// <summary>
        /// 快速创建测试充电桩（用于测试）
        /// </summary>
        /// <param name="name">名称</param>
        /// <param name="ip">IP地址</param>
        /// <param name="siteId">站点ID</param>
        /// <returns>创建成功返回true</returns>
        public static bool QuickAddStation(string name, string ip, int? siteId = null)
        {
            var dataService = ChargeStationDataService.Instance;

            var station = new ChargeStation
            {
                Name = name,
                IpAddress = ip,
                Port = 502,
                SetVoltage = 220.0,
                SetElectricCurrent = 32.0,
                Status = ChargeStationStatus.Idle,
                Enabled = true,
                SiteId = siteId,
                Remarks = $"快速创建于 {DateTime.Now}"
            };

            bool success = dataService.AddStation(station, out string errorMsg);

            if (success)
            {
                Diagnosis.Log($"快速创建充电桩: {name}", "ChargeStation", true);
            }
            else
            {
                Diagnosis.Log($"快速创建充电桩失败: {errorMsg}", "ChargeStation", true);
            }

            return success;
        }

        /// <summary>
        /// 显示充电桩选择对话框
        /// </summary>
        /// <param name="filterByStatus">按状态过滤（null表示显示全部）</param>
        /// <returns>选中的充电桩，取消则返回null</returns>
        public static ChargeStation ShowStationSelectionDialog(ChargeStationStatus? filterByStatus = null)
        {
            var dataService = ChargeStationDataService.Instance;
            var stations = dataService.GetAllStations();

            if (filterByStatus.HasValue)
            {
                stations = stations.Where(s => s.Status == filterByStatus.Value).ToList();
            }

            if (stations.Count == 0)
            {
                MessageBox.Show("没有符合条件的充电桩", "提示", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                return null;
            }

            // 创建简单的选择对话框
            using (var dialog = new Form())
            {
                dialog.Text = "选择充电桩";
                dialog.Size = new System.Drawing.Size(500, 400);
                dialog.StartPosition = FormStartPosition.CenterParent;

                var listBox = new ListBox
                {
                    Dock = DockStyle.Fill,
                    Font = new System.Drawing.Font("微软雅黑", 10F)
                };

                foreach (var station in stations)
                {
                    listBox.Items.Add($"[{station.StationId}] {station.Name} - {station.IpAddress}:{station.Port} - {GetStatusText(station.Status)}");
                }

                var btnOK = new Button
                {
                    Text = "确定",
                    DialogResult = DialogResult.OK,
                    Dock = DockStyle.Bottom,
                    Height = 40
                };

                dialog.Controls.Add(listBox);
                dialog.Controls.Add(btnOK);
                dialog.AcceptButton = btnOK;

                if (dialog.ShowDialog() == DialogResult.OK && listBox.SelectedIndex >= 0)
                {
                    return stations[listBox.SelectedIndex];
                }

                return null;
            }
        }

        /// <summary>
        /// 获取状态文本
        /// </summary>
        private static string GetStatusText(ChargeStationStatus status)
        {
            switch (status)
            {
                case ChargeStationStatus.Idle: return "空闲";
                case ChargeStationStatus.Charging: return "充电中";
                case ChargeStationStatus.Fault: return "故障";
                case ChargeStationStatus.Battery: return "离线";
                default: return "未知";
            }
        }

        /// <summary>
        /// 批量更新充电桩在线状态（用于定期监控）
        /// </summary>
        /// <param name="timeout">超时时间（毫秒）</param>
        /// <returns>更新的充电桩数量</returns>
        public static int UpdateOnlineStatus(int timeout = 3000)
        {
            var dataService = ChargeStationDataService.Instance;
            var stations = dataService.GetAllStations().Where(s => s.Enabled).ToList();
            int updatedCount = 0;

            foreach (var station in stations)
            {
                try
                {
                    // 这里应该实际ping充电桩，此处仅演示
                    bool isOnline = PingStation(station.IpAddress, station.Port, timeout);

                    var expectedStatus = isOnline 
                        ? (station.Status == ChargeStationStatus.Battery ? ChargeStationStatus.Idle : station.Status)
                        : ChargeStationStatus.Battery;

                    if (station.Status != expectedStatus && 
                        (station.Status == ChargeStationStatus.Battery || expectedStatus == ChargeStationStatus.Battery))
                    {
                        if (dataService.UpdateStationStatus(station.StationId, expectedStatus))
                        {
                            updatedCount++;
                            Diagnosis.Log($"充电桩 {station.Name} 状态更新为: {GetStatusText(expectedStatus)}", 
                                "ChargeStation", true);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Diagnosis.Log($"检查充电桩 {station.Name} 在线状态失败: {ex.Message}", 
                        "ChargeStation");
                }
            }

            return updatedCount;
        }

        /// <summary>
        /// Ping 充电桩（检查连通性）
        /// </summary>
        private static bool PingStation(string ip, int port, int timeout)
        {
            try
            {
                using (var client = new System.Net.Sockets.TcpClient())
                {
                    var result = client.BeginConnect(ip, port, null, null);
                    var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(timeout));

                    if (success)
                    {
                        client.EndConnect(result);
                        return true;
                    }
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }
    }
}