using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using Kreta.Client.ClientBase;
using Kreta.Client.FileService.Configuration;
using Kreta.Client.FileService.Extension;
using Kreta.Client.FileService.Request;
using Kreta.Client.FileService.Response;
using Kreta.Framework;
using Kreta.Framework.Exceptions;
using Kreta.Resources;
using Newtonsoft.Json;

namespace Kreta.Client.FileService
{
    internal class FileServiceClient : RestSharpClientBase, IFileServiceClient
    {
        private readonly IFileServiceClientConfiguration fileServiceClientConfiguration;

        public FileServiceClient(IFileServiceClientConfiguration fileServiceClientConfiguration)
        {
            this.fileServiceClientConfiguration = fileServiceClientConfiguration ?? throw new ArgumentNullException(nameof(fileServiceClientConfiguration));
        }

        public GetTokenResponse GetPublicToken()
        {
            return GetToken(fileServiceClientConfiguration.GetPublicTokenRequestParameters());
        }

        public GetTokenResponse GetPrivateToken()
        {
            return GetToken(fileServiceClientConfiguration.GetPrivateTokenRequestParameters());
        }

        public FileUploadResponse Upload(string publicToken, IFileUploadRequest fileUploadRequest)
        {
            return ExceptionLogger(() =>
            {
                BaseUrl = fileServiceClientConfiguration.FileUploadUrl;

                var relativeUri = "/ideiglenesfajlok";

                var response = Post(relativeUri, publicToken.GetAuthorizationHeaderWithMulitpartFrom(), fileList: new List<Jira.Model.Request.File>
                {
                    new Jira.Model.Request.File
                    {
                        Name = "fajl",
                        FileName = fileUploadRequest.FileName,
                        Content = fileUploadRequest.Content,
                        ContentType = fileUploadRequest.ContentType,
                    }
                });

                if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    return new FileUploadResponse(true);
                }

                if (response.StatusCode == HttpStatusCode.OK)
                {
                    var successResponse = JsonConvert.DeserializeObject<FileUploadSuccessResponse>(response.Result);

                    return new FileUploadResponse(successResponse.FajlAzonosito, successResponse.Utvonal, successResponse.FajlMeretByteLength);
                }

                var failureResponse = JsonConvert.DeserializeObject<FileUploadFailureResponse>(response.Result);

                return new FileUploadResponse(failureResponse.Uzenet);
            });
        }

        public FileFinalizeResponse Finalize(string intezmenyAzonosito, string privateToken, FileFinalizeRequest fileFinalizeRequest)
        {
            return ExceptionLogger(() =>
            {
                BaseUrl = fileServiceClientConfiguration.FileUploadUrl;

                var relativeUri = $"/fajlok/{intezmenyAzonosito}";

                var response = Post(relativeUri, privateToken.GetAuthorizationHeaderWithJson(), body: fileFinalizeRequest);

                if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    return new FileFinalizeResponse(true);
                }

                if (response.StatusCode == HttpStatusCode.OK)
                {
                    var internalResponse = JsonConvert.DeserializeObject<InternalFileFinalizeResponse>(response.Result);

                    if (internalResponse.IsSikeres)
                    {
                        return new FileFinalizeResponse();
                    }

                    var errormessage = string.Join(", ", internalResponse.Fajlok.Where(x => !string.IsNullOrWhiteSpace(x.HibaSzoveg)).Select(x => x.HibaSzoveg));

                    errormessage = !string.IsNullOrWhiteSpace(errormessage) ? errormessage : internalResponse.HibaSzoveg;

                    return new FileFinalizeResponse(errormessage);
                }

                return new FileFinalizeResponse(ErrorResource.IsmeretlenHibaTortent);
            });
        }

        public GetUrlResponse GetUrl(string intezmenyAzonosito, string privateToken, GetUrlRequest getUrlRequest)
        {
            return ExceptionLogger(() =>
            {
                BaseUrl = fileServiceClientConfiguration.FileUploadUrl;

                var relativeUri = $"/fajl-url/{intezmenyAzonosito}";

                var response = Get(relativeUri, privateToken.GetAuthorizationHeaderWithJson(), getUrlRequest.GetUrlRequestParameters());

                if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    return new GetUrlResponse(true);
                }

                if (response.StatusCode == HttpStatusCode.OK)
                {
                    return GetUrlResponse.GetUrlResponseWithUrl(response.Result);
                }

                var failureResponse = JsonConvert.DeserializeObject<GetUrlFailureResponse>(response.Result);

                return new GetUrlResponse(failureResponse.Uzenet);
            });
        }

        public FileDeleteResponse Delete(string intezmenyAzonosito, string privateToken, FileDeleteRequest fileDeleteRequest)
        {
            return ExceptionLogger(() =>
            {
                BaseUrl = fileServiceClientConfiguration.FileUploadUrl;

                var relativeUri = $"/fajlok/{intezmenyAzonosito}";

                var response = Delete(relativeUri, privateToken.GetAuthorizationHeaderWithJson(), body: fileDeleteRequest);

                if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    return new FileDeleteResponse(true);
                }

                if (response.StatusCode == HttpStatusCode.NoContent)
                {
                    return new FileDeleteResponse();
                }

                var failureResponse = JsonConvert.DeserializeObject<FileDeleteFailureResponse>(response.Result);

                return new FileDeleteResponse(failureResponse.Uzenet);
            });
        }

        private GetTokenResponse GetToken(Dictionary<string, string> tokenRequestParameters)
        {
            return ExceptionLogger(() =>
            {
                BaseUrl = fileServiceClientConfiguration.IDPUrl;

                var relativeUri = "/connect/token";

                var response = Post(relativeUri, HeaderExtension.GetFormUrlEncodedHeader(), tokenRequestParameters);

                if (response.StatusCode == HttpStatusCode.OK)
                {
                    var successResponse = JsonConvert.DeserializeObject<GetTokenSuccessResponse>(response.Result);

                    return new GetTokenResponse(successResponse.AccessToken, successResponse.ExpiresIn);
                }

                var failureResponse = JsonConvert.DeserializeObject<GetTokenFailureResponse>(response.Result);

                return new GetTokenResponse(failureResponse.Error);
            });
        }

        private T ExceptionLogger<T>(Func<T> action) where T : IResponse, new()
        {
            try
            {
                return action();
            }
            catch (Exception ex)
            {
                SDAServer.Instance.Logger.ExceptionThrown(ex);

                return (T)Activator.CreateInstance(typeof(T), ExceptionUtil.ExceptionToString(ex));
            }
        }
    }
}