using CPRNIMS.Domain.UIContracts.Common;
using CPRNIMS.Domain.UIContracts.Inventory;
using CPRNIMS.Infrastructure.Dto.Common;
using CPRNIMS.Infrastructure.Dto.Inventory.Request;
using CPRNIMS.Infrastructure.Dto.Inventory.Response;
using CPRNIMS.Infrastructure.Helper;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace CPRNIMS.Domain.UIServices.Inventory
{
    public class RIS : IRIS
    {
        private readonly IConfiguration _configuration;
        private readonly TokenHelper _tokenHelper;
        private readonly IApiConfigurationService _apiConfigurationService;
        public RIS(IConfiguration configuration, TokenHelper tokenHelper,
            IApiConfigurationService apiConfigurationService)
        {
            _configuration = configuration;
            _tokenHelper = tokenHelper;
            _apiConfigurationService = apiConfigurationService;
        }
        #region Get
        public async Task<RISPagedResponse> GetRISPaged(RISPagedRequest request, CancellationToken ct)
        {
            try
            {
                var token = await _tokenHelper.GetValidTokenAsync();
                if (string.IsNullOrEmpty(token))
                    throw new InvalidOperationException("Token has been expired.");

                var baseEndpoint = _configuration["LLI:NonInvent:InventoryMgmt:GetRIS"]
                    ?? throw new InvalidOperationException("GetRIS endpoint is not configured.");

                // ── Build query string — GET request, no body ──
                var qs = new StringBuilder(baseEndpoint).Append('?');
                qs.Append($"pageNumber={request.PageNumber}");
                qs.Append($"&pageSize={request.PageSize}");

                if (!string.IsNullOrWhiteSpace(request.SearchRISNo))
                    qs.Append($"&searchRISNo={Uri.EscapeDataString(request.SearchRISNo)}");

                if (!string.IsNullOrWhiteSpace(request.SearchItemName))
                    qs.Append($"&searchItemName={Uri.EscapeDataString(request.SearchItemName)}");

                if (!string.IsNullOrWhiteSpace(request.SearchIssuedTo))
                    qs.Append($"&searchIssuedTo={Uri.EscapeDataString(request.SearchIssuedTo)}");

                if (!string.IsNullOrWhiteSpace(request.Discipline))
                    qs.Append($"&discipline={Uri.EscapeDataString(request.Discipline)}");

                if (request.Status.HasValue)
                    qs.Append($"&status={request.Status.Value}");

                using var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token);

                // ── GET, no content body ──
                var response = await httpClient.GetAsync(qs.ToString(), ct);
                var json = await response.Content.ReadAsStringAsync(ct);

                if (!response.IsSuccessStatusCode)
                {
                    Console.WriteLine($"[GetRISPaged] Error {(int)response.StatusCode}: {json}");
                    return new RISPagedResponse { Data = [], RecordsTotal = 0 };
                }

                var result = JsonSerializer.Deserialize<RISPagedResponse>(json, _jsonOptions);
                return result ?? new RISPagedResponse();
            }
            catch (Exception ex)
            {
                ex.ToString();
                throw;
            }
           
        }
        #endregion
        #region Post Put
        public async Task<bool> ApproveRIS(ApproveRISRequest request, CancellationToken ct)
        {
            var token = await _tokenHelper.GetValidTokenAsync();
            if (string.IsNullOrEmpty(token))
                throw new InvalidOperationException("Token has been expired.");

            var endpoint = _configuration["LLI:NonInvent:InventoryMgmt:ApproveRIS"]
                ?? throw new InvalidOperationException("ApproveRIS endpoint is not configured.");

            using var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token);
            using var content = new StringContent(JsonSerializer.Serialize(request),Encoding.UTF8,"application/json");

            var response = await httpClient.PutAsync(endpoint, content, ct);
            var json = await response.Content.ReadAsStringAsync(ct);

            if (!response.IsSuccessStatusCode)
            {
                return false;
            }
            return true;
        }

        public async Task<bool> CancelRIS(CancelRISRequest request, CancellationToken ct)
        {
            var token = await _tokenHelper.GetValidTokenAsync();
            if (string.IsNullOrEmpty(token))
                throw new InvalidOperationException("Token has been expired.");

            var endpoint = _configuration["LLI:NonInvent:InventoryMgmt:CancelRIS"]
                ?? throw new InvalidOperationException("CancelRIS endpoint is not configured.");

            using var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token);
            using var content = new StringContent(
                JsonSerializer.Serialize(request),Encoding.UTF8,"application/json");

            var response = await httpClient.PutAsync(endpoint, content, ct);
            var json = await response.Content.ReadAsStringAsync(ct);

            if (!response.IsSuccessStatusCode)
            {
                return false;
            }
            return true;
        }
        public async Task<RISResponse> CreateRIS(CreateRISRequest request, CancellationToken ct)
        {
            var token = await _tokenHelper.GetValidTokenAsync();
            if (string.IsNullOrEmpty(token))
                throw new InvalidOperationException("Token has been expired.");


            var endpoint = _configuration["LLI:NonInvent:InventoryMgmt:CreateRIS"] ??
                           throw new InvalidOperationException("CreateRIS endpoint is not configured.");

            using var httpClient = _apiConfigurationService.CreateHttpClientWithDefaultHeaders(token);
            using var content = new StringContent(
                                       JsonSerializer.Serialize(request),
                                       Encoding.UTF8,
                                       "application/json");

            var response = await httpClient.PostAsync(endpoint, content,ct);

            if (!response.IsSuccessStatusCode)
            {
                return new RISResponse();
            }

            var json = await response.Content.ReadAsStringAsync();

            var result = JsonSerializer.Deserialize<ApiResponse<RISResponse>>(json, _jsonOptions);
             return result?.data ?? new RISResponse();
        }

        public Task<RISPagedResponse> GetRISById(int risId, CancellationToken ct)
        {
            throw new NotImplementedException();
        }

        private static readonly JsonSerializerOptions _jsonOptions = new()
        {
            PropertyNameCaseInsensitive = true
        };
        #endregion
    }
}