using Newtonsoft.Json;
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using HandyControl.Tools.Extension;
using SparkClient.Model.Common;
using SparkClient.Model.Entity.ApiEntity;

namespace SparkClient.Model.Services
{
    /// <summary>
    /// SOC 客户端服务类，用于与远程服务器进行交互，包括启动图片收集任务、获取图片、获取采集状态等操作。
    /// </summary>
    public class SOCClientService
    {
        // Log地址
        private const string LogFilePath = @"..\..\..\Resource\Document\log.txt";

        /// <summary>
        /// 基础URL，用于构建完整的API请求地址。
        /// </summary>
        private readonly string _baseUrl;

        /// <summary>
        /// 认证令牌，用于HTTP请求的认证。
        /// </summary>
        private readonly string _authToken;

        /// <summary>
        /// 构造函数，初始化基础URL和认证令牌。
        /// </summary>
        /// <param name="baseUrl">基础URL</param>
        /// <param name="authToken">认证令牌</param>
        public SOCClientService()
        {
            _baseUrl = "http://localhost:5000/api/SoC";
            _authToken = "your_basic_auth_token";
        }

        /// <summary>
        /// 发送GET请求的通用方法。
        /// </summary>
        /// <param name="url">请求的完整URL</param>
        /// <returns>HTTP响应</returns>
        private async Task<HttpResponseMessage> SendGetRequestAsync(string url)
        {
            using (var client = new HttpClient())
            {
                client.DefaultRequestHeaders.Add("Authorization", "Basic " + _authToken);
                return await client.GetAsync(url);
            }
        }

        /// <summary>
        /// 启动图片收集任务。
        /// </summary>
        /// <param name="lightLevel">光照级别</param>
        /// <returns>任务状态</returns>
        public async Task<string> CollectImagesAsync(int lightLevel)
        {
            string url = $"{_baseUrl}/collect_images?light_level={lightLevel}";
            var response = await SendGetRequestAsync(url);

            if (response.IsSuccessStatusCode)
            {
                var jsonResponse = await response.Content.ReadAsStringAsync();
                var result = JsonConvert.DeserializeObject<ResponseStatus>(jsonResponse);
                return result.Status;
            }
            else
            {
                return "collect_images_Error: " + (int)response.StatusCode;
            }
        }

        /// <summary>
        /// 获取指定索引的图片。
        /// </summary>
        /// <param name="index">图片索引</param>
        /// <returns>图片的字节数组</returns>
        public async Task<List<string>> RetrieveImageAsync(string savePath)
        {
            List<string> imageNames = new List<string>();
            // 读取图片接口
            int imageIndex = 0;
            while (true)
            {
                string url = $"{_baseUrl}/retrieve_image/{imageIndex}";
                var response = await SendGetRequestAsync(url);
                int status = (int)response.StatusCode;

                if (status == 200)
                {
                    byte[] imageBytes = await response.Content.ReadAsByteArrayAsync();
                    
                    // 获取 Content-Type 头以确定图片格式
                    string contentType = response.Content.Headers.ContentType.MediaType;
                    string fileExtension = GetFileExtension(contentType);

                    //string fileName = Path.Combine(savePath, $"image_{imageIndex}.bmp");
                    string fileName = Path.Combine(savePath, $"image_{imageIndex}{fileExtension}");
                    // 图片名称List
                    imageNames.Add(Path.GetFileName(fileName));
                    // 保存图片
                    await File.WriteAllBytesAsync(fileName, imageBytes);
                    imageIndex++;
                }
                else if (status == 425) 
                {
                    await Task.Delay(1000); 
                }
                else if (status == 410) 
                {
                    imageIndex++;
                }
                else if (status == 404) 
                {
                    return imageNames;
                }
            }
        }

        /// <summary>
        /// 获取图片采集状态。
        /// </summary>
        /// <returns>采集状态</returns>
        public async Task<string> CollectStatusAsync()
        {
            string url = $"{_baseUrl}/collect_status";
            var response = await SendGetRequestAsync(url);

            if (response.IsSuccessStatusCode)
            {
                var jsonResponse = await response.Content.ReadAsStringAsync();
                var result = JsonConvert.DeserializeObject<ResponseStatus>(jsonResponse);
                return result.Status;
            }
            else
            {
                return "collect_status_Error: " + (int)response.StatusCode;
            }
        }

        /// <summary>
        /// 处理图片收集、保存和状态检查。
        /// </summary>
        /// <param name="lightLevel">光照级别</param>
        /// <param name="savePath">图片保存路径</param>
        /// <returns>操作结果</returns>
        public async Task<SocResultEntity> ProcessImageCollectionAsync(int lightLevel, string savePath)
        {
            try
            {
                // 清理 savePath 文件夹
                if (Directory.Exists(savePath))
                {
                    Directory.Delete(savePath, true);
                }
                Directory.CreateDirectory(savePath);
                
                // 启动任务接口
                string startStatus = await CollectImagesAsync(lightLevel);
                // 成功
                if (startStatus != StatusCodes.Success)
                {
                    // 启动任务失败
                    return new SocResultEntity { Status = startStatus, Images = new List<string>() };
                }

                // 读取图片接口
                List<string> imageNames = await RetrieveImageAsync(savePath);
                if (imageNames.Count != 0)
                {
                    // 采集状态接口
                    string acquisitionStatus = await CollectStatusAsync();
                    // 成功
                    if (acquisitionStatus != StatusCodes.Success)
                    {
                        // 采集状态失败
                        return new SocResultEntity { Status = acquisitionStatus, Images = new List<string>() };                        
                    }
                }
                // 按下载时间排序图片名称
                return new SocResultEntity { Status = StatusCodes.Success, Images = imageNames };                
            }
            catch (Exception e)
            {
                // 日志记录
                // logger.Error(e, "发生异常");
                string logMessage = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] 发生异常: {e.Message}{Environment.NewLine}";
                File.AppendAllText(LogFilePath, logMessage);
                return new SocResultEntity { Status = StatusCodes.DeviceNotFound, Images = new List<string>() };                
            }
        }
        
        /// <summary>
        /// 根据给定的 MIME 类型获取对应的文件扩展名。
        /// </summary>
        /// <param name="contentType">HTTP 响应中的 Content-Type 头字段，表示内容的 MIME 类型。</param>
        /// <returns>与 MIME 类型对应的文件扩展名。</returns>
        /// <exception cref="InvalidOperationException">当传入的 MIME 类型不受支持时抛出此异常。</exception>
        private string GetFileExtension(string contentType)
        {
            switch (contentType.ToLower())
            {
                case "image/bmp":
                    return ".bmp";
                case "image/jpg":
                    return ".jpg";
                case "image/png":
                    return ".png";
                default:
                    throw new InvalidOperationException($"Unsupported content type: {contentType}");
            }
        }

    }
    

    /// <summary>
    /// 响应状态类，用于解析服务器返回的状态信息。
    /// </summary>
    public class ResponseStatus
    {
        /// <summary>
        /// 状态码
        /// </summary>
        public string Status { get; set; }

        /// <summary>
        /// 状态消息
        /// </summary>
        public string Message { get; set; }
    }
}