using System;
using Amazon.Lambda.Core;
using Amazon.Lambda.APIGatewayEvents;
using Newtonsoft.Json;
using MySqlConnector;
using System.Data;
using classes;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net;
using Model.ResponseModel;
using System.Collections.Generic;
using System.Linq;

namespace PMF
{
    public class QuickFines: Pmfbase
    {
        
        public async Task<APIGatewayProxyResponse> GetQuickFines(APIGatewayProxyRequest request, ILambdaContext context)
        {
            string statement = "IForce: GetQuickFines";
            string userId = "";
            APIGatewayProxyResponse response;
            int attribute = 0; //notice number
            string phaseDetail = string.Empty;
            MySqlDataReader _reader = null;

            try
            {
                if (!Helper.IsRequestEmpty(request))
                {
                    string validationMessage = string.Empty;

                    var validRequest = Helper.ValidateRequestParameters(ref validationMessage, request.QueryStringParameters, "noticeNumber", "Id");

                    if (validRequest)
                    {
                        var NoticeNumber = request.QueryStringParameters["noticeNumber"];
                        userId = request.QueryStringParameters["Id"];

                        object iForce = Constants.NO_RESPONSE;
                        object eNatis = Constants.NO_RESPONSE;

                        bool validNoticeNumberFormat = false;

                        //iForce
                        if (NoticeNumber.Contains('/')) //iForce format
                        {
                            try
                            {
                                var iForcehandler = new HttpClientHandler();

                                iForcehandler.ServerCertificateCustomValidationCallback = Helper.ServerCertificateCustomValidation;

                                var iForceClient = new HttpClient(iForcehandler)
                                {
                                    BaseAddress = new Uri(baseUrl),
                                    Timeout = TimeSpan.FromSeconds(Constants.TimeDefaultValue)
                                };

                                var iForceResponse = await iForceClient.GetAsync($"IForce/queryopenfines?Attribute={attribute}&FineQueryAttributeValue={NoticeNumber}");

                                var iForcebody = await iForceResponse.Content.ReadAsStringAsync();

                                if (iForceResponse.StatusCode == HttpStatusCode.OK)
                                {
                                    var payload = JsonConvert.DeserializeObject<IForceQueryFinesResponse>(iForcebody);
                                    payload.fines = payload.fines.ToList();

                                    var transformedFines = new List<FineStatus>();

                                    foreach (var fine in payload.fines)
                                    {
                                        var paidLocalStatus = PaymentChecker.CheckLocalPaymentStatus(fine.noticeNumber, _con);

                                        if (fine.paymentAllowed == false) paidLocalStatus = false;

                                        switch (fine.phase)
                                        {
                                            case 1:
                                                phaseDetail = "Notice";
                                                break;
                                            case 2:
                                                phaseDetail = "Summons";
                                                break;
                                            case 3:
                                                phaseDetail = "Court";
                                                break;
                                            case 4:
                                                phaseDetail = "Warrant";
                                                break;
                                            default:
                                                phaseDetail = "Unknown";
                                                break;

                                        }
                                        transformedFines.Add(new FineStatus
                                        {
                                            issuingAuthorityCode = fine.issuingAuthorityCode,
                                            districtName = fine.districtName,
                                            noticeNumber = fine.noticeNumber,
                                            offenceDate = fine.offenceDate,
                                            location = fine.location,
                                            idNumber = fine.idNumber,
                                            vehicleRegistrationNumber = fine.vehicleRegistrationNumber,
                                            phase = phaseDetail,
                                            paymentAllowed = fine.paymentAllowed,
                                            paymentNotAllowedCode = fine.paymentNotAllowedCode,
                                            dueDate = fine.dueDate,
                                            totalAmountDue = fine.totalAmountDue,
                                            contemptOfCourtAmount = fine.contemptOfCourtAmount,
                                            summonsNumber = fine.summonsNumber,
                                            caseNumber = fine.caseNumber,
                                            courtCode = fine.courtCode,
                                            courtName = fine.courtName,
                                            courtDate = fine.courtDate,
                                            warrantOfArrestNumber = fine.warrantOfArrestNumber,
                                            warrantOfArrestPending = fine.warrantOfArrestPending,
                                            evidence = fine.evidence,
                                            customerPaymentAllowed = paidLocalStatus
                                        });
                                    }

                                    var result = new IForceQueryFinesResponseStatusModel
                                    {
                                        transactionId = payload.transactionId,
                                        resultCode = payload.resultCode,
                                        resultDescription = payload.resultDescription,
                                        fines = transformedFines.ToList()
                                    };

                                    iForce = result;
                                    if (result.fines.Count == 0) iForce = "No fines found";
                                    
                                }
                                else
                                {
                                    _logger.WriteLog(userId, statement, iForcebody, "TMT");
                                    iForce = $"No fines found for NoticeNumber: {NoticeNumber}";
                                }
                                validNoticeNumberFormat = true;
                            }
                            catch
                            {
                                iForce = Constants.NO_RESPONSE;
                            }

                        }
                        else if (Helper.IsDigitsOnly(NoticeNumber))
                        {
                            //eNatis
                            var eNatishandler = new HttpClientHandler
                            {
                                ServerCertificateCustomValidationCallback = Helper.ServerCertificateCustomValidation
                            };

                            try
                            {
                                var eNatisClient = new HttpClient(eNatishandler)
                                {
                                    BaseAddress = new Uri(baseUrl),
                                    Timeout = TimeSpan.FromSeconds(Constants.TimeDefaultValue)
                                };

                                var eNatisResponse = await eNatisClient.GetAsync($"infringement/queryinfringement?InfringementNoticeNumber={NoticeNumber}");

                                var body = await eNatisResponse.Content.ReadAsStringAsync();

                                if (eNatisResponse.StatusCode == HttpStatusCode.OK)
                                {
                                    eNatis = JsonConvert.DeserializeObject(body);
                                }
                                else
                                {
                                    _logger.WriteLog(userId, statement, body, "TMT");
                                    eNatis = $"No fines found for NoticeNumber: {NoticeNumber}";
                                }
                                validNoticeNumberFormat = true;
                            }
                            catch
                            {
                                eNatis = Constants.NO_RESPONSE;
                            }

                        }
                        if (!validNoticeNumberFormat)
                        {
                            return HttpService.CreateResponse(200, payload: $"Format: {NoticeNumber} is incorrect");
                        }

                        var responseBody = new
                        {
                            iForce = iForce,
                            eNatis = eNatis
                        };

                        return HttpService.CreateResponse(200, payload: responseBody);
                    }
                    else
                    {
                        _logger.LogMessage(context, $"Processing request failed invalid request");
                        response = HttpService.CreateResponse(400, payload: $"{validationMessage}");
                        return response;
                    }

                }
                else
                {
                    _logger.LogMessage(context, $"Processing request failed invalid request");
                    response = HttpService.CreateResponse(400, payload: "No parameters provided");
                    return response;
                }
            }
            catch (Exception ex)
            {
                _logger.WriteLog(userId, statement, ex.Message, "TMT");
                return HttpService.CreateResponse(500, payload: ex.Message);
            }
            finally
            {
                if (_reader != null) _reader.Close();
                if (_con != null || _con.State == ConnectionState.Open) _con.Close();
            }
        }

    }

}