using System.Net.Http.Json;
using System.Text;
using AutoDispathingWork.Utils;
using LiteDB;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using WorkerService1.Domains;
using WorkerService1.Dto;
using WorkerService1.Dto.Configuration;
using WorkerService1.Dto.QueryRequest;
using WorkerService1.Dto.QueryResponse;
using WorkerService1.Utils;
using JsonSerializer = System.Text.Json.JsonSerializer;
using Utilities = WorkerService1.Utils.Utilities;

namespace WorkerService1.Services;

public class SpiderServices
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IOptionsMonitor<ClientOptions> _optionsMonitor;
    private readonly IMemoryCache _memoryCache;
    private readonly ILogger<SpiderServices> _logger;
    private readonly IServiceProvider _serviceProvider;

    public SpiderServices(IHttpClientFactory httpClientFactory, IOptionsMonitor<ClientOptions> optionsMonitor,
        IMemoryCache memoryCache, ILogger<SpiderServices> logger, IServiceProvider serviceProvider)
    {
        _httpClientFactory = httpClientFactory;
        _optionsMonitor = optionsMonitor;
        _memoryCache = memoryCache;
        _logger = logger;
        _serviceProvider = serviceProvider;
    }


    // private ClientOptions GetClientOptions => _serviceProvider.CreateScope().ServiceProvider
    //     .GetRequiredService<SettingServices>()
    //     .GetClientOptions();


    public async Task<SpiderResponse<LoginResultData>> Login()
    {
        using var scope = _serviceProvider.CreateScope();
        using var client = _httpClientFactory.CreateClient();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var loginApi = getClientOptions.LoginUrl;
        var json = $@"
                {{""userName"":""{getClientOptions.UserName}"",""userPwd"":""{getClientOptions.Password}"",""type"":""account"",""clientAppId"":""megcity-web""}}
            ";
        client.DefaultRequestHeaders.Add("Module-Alias", "pending-forward");
        client.DefaultRequestHeaders.Add("Module-Source", "megcity-web");
        client.DefaultRequestHeaders.Add("Origin", _optionsMonitor.CurrentValue.ApiGateway);
        var response = await client.PostAsync(loginApi, new StringContent(json, Encoding.UTF8, "application/json"));
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("登录返回: {tokenRes}", respJsonStr);
        var tokenRes = JsonSerializer.Deserialize<LoginResponse>(respJsonStr);
        if (response.IsSuccessStatusCode)
        {
            if (tokenRes?.Code == 0)
            {
                _logger.LogInformation("成功登录, token: {token}", tokenRes?.Data?.Token);
                return new SpiderResponse<LoginResultData>()
                {
                    IsSuccess = true,
                    Result = tokenRes.Data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功登录"
                };
            }
        }

        return new SpiderResponse<LoginResultData>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "登录失败"
        };
    }

    public async Task<string?> GetToken()
    {
        var token = await _memoryCache.GetOrCreateAsync(nameof(GetToken), async entry =>
        {
            var loginRes = await Login();
            if (!loginRes.IsSuccess)
            {
                entry.AbsoluteExpiration = DateTimeOffset.Now;
                return null;
            }

            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(loginRes.Result?.ExpireTime / 1000 ?? 0);
            return loginRes.Result?.Token;
        });
        if (string.IsNullOrWhiteSpace(token)) _memoryCache.Remove(nameof(GetToken));
        return token;
    }


    public async Task<SpiderResponse<QueryRespData>> GetTaskList(int state)
    {
        // "headers": {
        //     "accept": "application/json, text/plain, */*",
        //     "accept-language": "zh-CN,zh;q=0.9",
        //     "authorization": "WVPCDLzQeRWYySPkQMuLAislgqfQJuubaHmDnfgyRkSxNCpbwzTgOrvtjSeg",
        //     "client-app-id": "megcity-web",
        //     "content-type": "application/json;charset=UTF-8",
        //     "module-alias": "pending-forward",
        //     "module-source": "megcity-web"
        // },
        // "referrer": "http://33.10.72.100/megcity/",
        // "referrerPolicy": "strict-origin-when-cross-origin",
        var token = await GetToken();
        using var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("authorization", $"{token}");
        client.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9");
        client.DefaultRequestHeaders.Add("client-app-id", "megcity-web");
        client.DefaultRequestHeaders.Add("module-alias", "pending-forward");
        client.DefaultRequestHeaders.Add("module-source", "megcity-web");
        // var beginTime = DateTime.Now.AddMonths(-1);
        var startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
        var beginTs = (long)(DateTime.Now.AddMonths(-1) - startTime).TotalMilliseconds;
        var endTs = (long)(DateTime.Now - startTime).TotalMilliseconds;
        var body = new QueryReq
        {
            State = new int[] { state },
            PageNo = 1,
            PageSize = 50,
            SortType = new int[] { 20, 10 },
            CreateStartTime = (long)beginTs,
            CreateEndTime = (long)endTs
        };
        // {"state":[3],"pageNo":1,"pageSize":50,"sortType":[40,10],"handleStartTime":1697293650750,"handleEndTime":1699885650750}
        // {"state":[1],"pageNo":1,"pageSize":50,"sortType":[20,10],"createStartTime":1697290618034,"createEndTime":1699882618034}
        // {\"state\":[1],\"pageNo\":1,\"pageSize\":50,\"sortType\":[20,10],\"createStartTime\":1697204639551,\"createEndTime\":1697204639551}
        using var scope = _serviceProvider.CreateScope();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var taskPath = getClientOptions.GetTaskUrl;
        var response = await client.PostAsync(taskPath,
            new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json"));
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("获得列表返回json: {respJsonStr}", respJsonStr);
        var spiderRes = JsonSerializer.Deserialize<QueryResp>(respJsonStr);
        if (response.IsSuccessStatusCode)
        {
            if (spiderRes?.code == 0)
            {
                _logger.LogInformation("成功获取监控结果");

                return new SpiderResponse<QueryRespData>()
                {
                    IsSuccess = true,
                    Result = spiderRes.data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功获取监控结果"
                };
            }
        }

        return new SpiderResponse<QueryRespData>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "获取监控结果失败"
        };
    }


    // {"pageNo":1,"pageSize":20,"condition":{"roleIds":["a2e267c0-d88d-4ecb-a4b5-d904e85dfbb6"],"enabled":"null"}}
    public async Task<SpiderResponse<PageData<UserRecord>>> GetUsers(UserQuery? query = null)
    {
        var token = await GetToken();
        using var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("authorization", $"{token}");
        client.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9");
        client.DefaultRequestHeaders.Add("client-app-id", "megcity-web");
        client.DefaultRequestHeaders.Add("module-alias", "pending-forward");
        client.DefaultRequestHeaders.Add("module-source", "megcity-web");
        var request = query ?? new UserQuery();
        using var scope = _serviceProvider.CreateScope();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var userPath = getClientOptions.GetUserUrl;
        var response = await client.PostAsync(userPath,
            new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json"));
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("获得列表返回json: {respJsonStr}", respJsonStr);
        var spiderRes = JsonSerializer.Deserialize<UserResp>(respJsonStr);
        if (response.IsSuccessStatusCode)
        {
            if (spiderRes?.Code == 0)
            {
                _logger.LogInformation("成功获取监控结果");

                return new SpiderResponse<PageData<UserRecord>>()
                {
                    IsSuccess = true,
                    Result = spiderRes.Data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功获取监控结果"
                };
            }
        }

        return new SpiderResponse<PageData<UserRecord>>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "获取监控结果失败"
        };
    }

    //{"acceptTypeCode":"A2-01-10","target":2,"handlerId":"66fa9261-16f6-49aa-a391-5848f40301e0","typeCode":"A2-01-10"}
    //{ "code": 0, "msg": "SUCCESS",  "data": {} }
    public async Task<SpiderResponse<object>> DispatchTask(string caseNumber, string cameraName, string typeCode)
    {
        var token = await GetToken();
        using var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("authorization", $"{token}");
        client.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9");
        client.DefaultRequestHeaders.Add("client-app-id", "megcity-web");
        client.DefaultRequestHeaders.Add("module-alias", "pending-forward");
        client.DefaultRequestHeaders.Add("module-source", "megcity-web");

        var (handlerId,phone, userRealName) = await GetUserIdByCamera(cameraName);
        if (string.IsNullOrWhiteSpace(handlerId))
        {
            return new SpiderResponse<object>()
            {
                IsSuccess = false,
                Result = null,
                Code = SpiderResponseCode.Fail,
                Message = $"分发任务失败, 案件编号:{caseNumber}, 未找到摄像头:{cameraName}对应的处理人员"
            };
        }

        var request = new DispatchReq
        {
            AcceptTypeCode = typeCode,
            Target = 2,
            HandlerId = handlerId,
            TypeCode = typeCode
        };
        using var scope = _serviceProvider.CreateScope();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var dispatchPath = string.Format(getClientOptions.DiposeOrderUrl, caseNumber);

        var response = await client.PostAsync(dispatchPath,
            new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json"));
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("获得列表返回json: {respJsonStr}", respJsonStr);
        var spiderRes = JsonSerializer.Deserialize<DispatchResp>(respJsonStr);

        if (response.IsSuccessStatusCode)
        {
            if (spiderRes?.code == 0)
            {
                var msg = $"成功分发任务，任务编号:{caseNumber},任务地址:{cameraName},任务类型:{typeCode},处理人:{userRealName}";
                var smsService = scope.ServiceProvider.GetService<SmsService>();
                await smsService.SendSmsAsync(phoneNumber:phone, $"{userRealName}您好，您有一条新案件，请及时处置，谢谢。",caseNumber);
                _logger.LogInformation(msg);

                return new SpiderResponse<object>()
                {
                    IsSuccess = true,
                    Result = spiderRes.data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功分发任务"
                };
            }
        }

        return new SpiderResponse<object>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "分发任务失败"
        };
    }


    // api/megcity/v1/events/pass
    public async Task<SpiderResponse<object>> CloseFile(string caseNumber, string suggestion)
    {
        var token = await GetToken();
        using var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("authorization", $"{token}");
        client.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9");
        client.DefaultRequestHeaders.Add("client-app-id", "megcity-web");
        client.DefaultRequestHeaders.Add("module-alias", "pending-forward");
        client.DefaultRequestHeaders.Add("module-source", "megcity-web");

        var form = new MultipartFormDataContent();
        //Region为请求文件接口需要的参数，根据调用接口参数而定
        form.Add(new StringContent(caseNumber), "caseNumber");
        form.Add(new StringContent(suggestion), "suggestion");
        using var scope = _serviceProvider.CreateScope();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var closeFile = getClientOptions.CloseFileUrl;

        var response = await client.PostAsync(closeFile, form);
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("结案响应: {respJsonStr}", respJsonStr);
        var spiderRes = JsonSerializer.Deserialize<CloseResp>(respJsonStr);

        if (response.IsSuccessStatusCode)
        {
            if (spiderRes?.code == 0)
            {
                _logger.LogInformation("成功结案");
                _serviceProvider.GetService<SmsService>()?
                    .SendSmsAsync("13700000000", "您有一条案件已经结案", caseNumber);
                return new SpiderResponse<object>()
                {
                    IsSuccess = true,
                    Result = spiderRes.data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功结案"
                };
            }
        }

        return new SpiderResponse<object>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "结案失败"
        };
    }

    //api/galaxy/v1/device/cameras:search
    public async Task<SpiderResponse<PageData<CameraItem>>> GetCameras(string? name = null)
    {
        var token = await GetToken();
        using var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("authorization", $"{token}");
        client.DefaultRequestHeaders.Add("accept-language", "zh-CN,zh;q=0.9");
        client.DefaultRequestHeaders.Add("client-app-id", "megcity-web");
        client.DefaultRequestHeaders.Add("module-alias", "pending-forward");
        client.DefaultRequestHeaders.Add("module-source", "megcity-web");
        var request = $@"
    {{""managementIds"":[""6e9232ef-7b84-11e8-86b1-6c92bf4e6960""],""name"":""{name}"" ,""action"":""all"",""pageNo"":1,""pageSize"":200}}
";
        using var scope = _serviceProvider.CreateScope();
        var getClientOptions = scope.ServiceProvider.GetService<SettingServices>()?
            .GetClientOptions();
        var getCamersPath = getClientOptions.GetCamerasUrl;
        var response = await client.PostAsync(getCamersPath,
            new StringContent(request, Encoding.UTF8, "application/json"));
        var respJsonStr = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("获得列表返回json: {respJsonStr}", respJsonStr);
        var spiderRes = JsonSerializer.Deserialize<CameraResponse>(respJsonStr);
        if (response.IsSuccessStatusCode)
        {
            if (spiderRes?.Code == 0)
            {
                _logger.LogInformation("成功获取监控结果");
                foreach (var record in spiderRes.Data.Records)
                {
                    _logger.LogInformation("摄像头: {name}", record.name);
                    var transferRes = GpsUtil.BaiduToGaode(record.lat, record.lon);
                    record.lat = transferRes.Item1;
                    record.lon = transferRes.Item2;
                }

                return new SpiderResponse<PageData<CameraItem>>()
                {
                    IsSuccess = true,
                    Result = spiderRes.Data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功获取摄像头结果"
                };
            }
        }

        return new SpiderResponse<PageData<CameraItem>>()
        {
            IsSuccess = false,
            Result = null,
            Code = SpiderResponseCode.Fail,
            Message = "获取摄像头失败"
        };
    }

    public async Task<(string userId,string phone, string userRealName )> GetUserIdByCamera(string cameraAddress)
    {
        using var scope = _serviceProvider.CreateScope();
        var camerasResp = await GetCameras(cameraAddress);
        var camera = camerasResp.Result?.Records.FirstOrDefault();
        if (camera == null) return (string.Empty,string.Empty, string.Empty);
        var location = new Points(camera.lon, camera.lat);
        var db = scope.ServiceProvider.GetService<ApplicationDbContext>()
            .Polygons;
        var polygonDb = db;
        var polygons = await polygonDb.ToListAsync();
        foreach (var polygon in polygons)
        {
            if (location.IsPointInsidePolygon(polygon))
            {
                return (polygon.UserId, polygon.PhoneNumber, polygon.UserName);
            }
        }

        return (string.Empty, string.Empty,string.Empty);
    }
}