using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using WorkerService1.Dto;
using WorkerService1.Dto.Configuration;
using WorkerService1.Dto.QueryRequest;
using WorkerService1.Dto.QueryResponse;

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 IOptionsMonitor<ClientOptions> OptionsMonitor => _serviceProvider.CreateScope().ServiceProvider
        .GetRequiredService<IOptionsMonitor<ClientOptions>>();



    public async Task<SpiderResponse<LoginResultData>> Login()
    {
        using var client = _httpClientFactory.CreateClient();
        var loginApi = OptionsMonitor.CurrentValue.LoginUrl;
        var json = $@"
                {{""userName"":""{_optionsMonitor.CurrentValue.UserName}"",""userPwd"":""{_optionsMonitor.CurrentValue.Password}"",""type"":""account"",""clientAppId"":""megcity-web""}}
            ";
        client.DefaultRequestHeaders.Add("Module-Alias", "pending-forward");
        client.DefaultRequestHeaders.Add("Module-Source", "megcity-web");
        client.DefaultRequestHeaders.Add("Origin", "http://121.4.75.240");
        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()
    {
        return await _memoryCache.GetOrCreateAsync(nameof(GetToken), async entry =>
        {
            var loginRes = await Login();
            if (!loginRes.IsSuccess) return null;
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(loginRes.Result?.ExpireTime ?? 0);
            return loginRes.Result?.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}
        var taskPath = OptionsMonitor.CurrentValue.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<Data>> GetUsers()
    {
        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 = new UserQuery();
        var userPath = OptionsMonitor.CurrentValue.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<Data>()
                {
                    IsSuccess = true,
                    Result = spiderRes.Data,
                    Code = SpiderResponseCode.Success,
                    Message = "成功获取监控结果"
                };
            }
        }

        return new SpiderResponse<Data>()
        {
            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 handlerId, 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 request = new DispatchReq
        {
            AcceptTypeCode = typeCode,
            Target = 2,
            HandlerId = handlerId,
            TypeCode = typeCode
        };
        var dispatchPath = string.Format(OptionsMonitor.CurrentValue.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)
            {
                _logger.LogInformation("成功分发任务");

                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");
        var closeFile = OptionsMonitor.CurrentValue.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("成功结案");

                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 = "结案失败"
        };
    }
}