using System;
using System.Collections.Generic;
using Architecture.DataModels.Constants;
using Architecture.Services.Interface;
using Assets.Scripts.Architecture.Services.Interface;
using Assets.Scripts.DataModels;
using Assets.Scripts.DataModels.BackendRequest;
using Assets.Scripts.NetworkingHelpers.Responses;
using Assets.Scripts.Services.Interfaces;
using UnityEngine;

namespace Architecture.Services.Implementation
{
    class InternalApiService : IInternalApiService
    {
        private INetworkingService _networkingService;
        private INetworkingClientDataService _networkingClientDataService;
        private IParseService _parseService;
        private IProfileContainer _profileContainer;
        private IFileService _fileService;

        public event Action<Token> OnInternalApiRequestLoginAsyncSucces = delegate { };
        public event Action<string> OnInternalApiRequestLoginAsyncFailed = delegate { };

        public event Action<string> OnInternalApiRequestUserRegistrationAsyncSucces = delegate { };
        public event Action<string> OnInternalApiRequestUserRegistrationAsyncFailed = delegate { };

        public event Action<string> OnInternalApiRequestAdminRegistrationAsyncSucces = delegate { };
        public event Action<string> OnInternalApiRequestAdminRegistrationAsyncFailed = delegate { };

        public event Action<string> OnInternalApiPostProcessPointFileAsyncSucces = delegate { };
        public event Action<string> OnInternalApiPostProcessPointFileAsyncFailed = delegate { };

        public event Action<List<TouristlCityData>> OnInternalApiPostGetCityPointsAsyncSucces = delegate { };
        public event Action<string> OnInternalApiPostGetCityPointsAsyncFailed = delegate { };

        public event Action<string> OnInternalApiPutUploadFileAsyncSucces = delegate { };
        public event Action<string> OnInternalApiPutUploadFileAsyncFailed = delegate { };

        public event Action<Texture2D, string> OnInternalApiGetPictureAndCasheAsyncSucces = delegate { };
        public event Action<string> OnInternalApiGetPictureAndCasheAsyncFailed = delegate { };

        public InternalApiService(INetworkingService networkingService, INetworkingClientDataService networkingClientDataService, IParseService parseService, IProfileContainer profileContainer, IFileService fileService)
        {
            _networkingService = networkingService;
            _networkingClientDataService = networkingClientDataService;
            _parseService = parseService;
            _profileContainer = profileContainer;
            _fileService = fileService;

            InitSubscribtions();
        }

        private void InitSubscribtions()
        {
            UnityEngine.Debug.Log("Inited");
            _networkingService.OnPostLoginAsyncSucces += HandleSuccesLogin;
            _networkingService.OnPostLoginAsyncFailed += HandleFailedLogin;

            _networkingService.OnPostUserRegistrationAsyncSucces += HandleSuccesUserRegistration;
            _networkingService.OnPostUserRegistrationAsyncFailed += HandleFailedUserRegistration;

            _networkingService.OnPostAdminRegistrationAsyncSucces += HandleSuccesAdminRegistration;
            _networkingService.OnPostAdminRegistrationAsyncFailed += HandleFailedAdminRegistration;

            _networkingService.OnPostProcessPointFileAsyncSucces += HandleSuccesProcessPointFile;
            _networkingService.OnPostProcessPointFileAsyncFailed += HandleFailedProcessPointFile;

            _networkingService.OnPostGetCityPointsAsyncSucces += HandleSuccesGetCityPoints;
            _networkingService.OnPostGetCityPointsAsyncFailed += HandleFailedGetCityPoints;

            _networkingService.OnPutUploadFileAsyncSucces += HandleSuccesPutUploadFile;
            _networkingService.OnPutUploadFileAsyncFailed += HandleFailedPutUploadFile;

            _networkingService.OnGetPictureAsyncSucces += HandleSuccesGetPicture;
            _networkingService.OnGetPictureAsyncFailed += HandleFailedGetPicture;
        }

        public void RequestLogin(string usernameParam, string passwordParam)
        {
            UnityEngine.Debug.Log("RequestLogin");
            var body = new LogingAndPasswordContainer
            {
                username = usernameParam,
                password = passwordParam
            };
            string serializebody = _parseService.SerializeObject(body);
            _networkingService.PostLoginAsync(BackendUries.LoginUri, _networkingClientDataService.GetLoginHeader, serializebody);
        }

        public void RequestUserRegistration(string usernameParam, string passwordParam)
        {
            UnityEngine.Debug.Log("RequestUserRegistration");
            var body = new LogingAndPasswordContainer
            {
                username = usernameParam,
                password = passwordParam
            };
            string serializebody = _parseService.SerializeObject(body);
            _networkingService.PostUserRegistrationAsync(BackendUries.UserRegistrationUri, _networkingClientDataService.GetLoginHeader, serializebody);
        }

        public void RequestAdminRegistration(string usernameParam, string passwordParam)
        {
            UnityEngine.Debug.Log("RequestAdminRegistration");
            var body = new LogingAndPasswordContainer
            {
                username = usernameParam,
                password = passwordParam
            };
            string serializebody = _parseService.SerializeObject(body);
            _networkingService.PostAdminRegistrationAsync(BackendUries.AdminRegistrationUri, _networkingClientDataService.GetLoginHeaderWithToken, serializebody);
        }

        public void PostProcessPointFile(string countryCode, string cityName, List<string> filenames)
        {
            UnityEngine.Debug.Log("PostProcessPointFile");
            var body = new ProcessPointContainer
            {
                country = countryCode,
                city = cityName,
                filenames = filenames
            };
            string serializebody = _parseService.SerializeObject(body);
            _networkingService.PostProcessPointFileAsync(BackendUries.ProcessPointFileUri, _networkingClientDataService.GetLoginHeaderWithToken, serializebody);
        }

        public void PostGetCityPoints(string countryCode, string cityName)
        {
            UnityEngine.Debug.Log("PostGetCityPoints");
            var body = new LocationPostContainer
            {
                code = countryCode,
                city = cityName
            };
            var serializebody = _parseService.SerializeObject(body);
            _networkingService.PostGetCityPointsAsync(BackendUries.GetCityPointsUri, _networkingClientDataService.GetLoginHeaderWithToken, serializebody, countryCode);
        }

        public void PutUploadFile(string filepath)
        {
            UnityEngine.Debug.Log("PutUploadFile");
            var file = _fileService.ReadFileAsBytes(filepath);
            _networkingService.PutUploadFileAsync(BackendUries.UploadFileUri, _networkingClientDataService.GetTokenHeader, file);
        }

        public void GetPictureAndCashe(string uri, string fullFilePath)
        {
            UnityEngine.Debug.Log("GetPictureAndCashe");
            _networkingService.GetPictureOnMarkerAsync(fullFilePath, uri);
        }

        #region ResponceHandlers
        private void HandleSuccesLogin(string result)
        {
            UnityEngine.Debug.Log("HandleSuccesLogin");
            var resultInfo = _parseService.ParseRawResponseTo<Token>(result);
            _profileContainer.UserToken = resultInfo;
            OnInternalApiRequestLoginAsyncSucces?.Invoke(resultInfo);
        }

        private void HandleFailedLogin(string result)
        {
            UnityEngine.Debug.Log("HandleFailedLogin");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiRequestLoginAsyncFailed?.Invoke(resultInfo);
        }

        private void HandleSuccesUserRegistration(string result)
        {
            UnityEngine.Debug.Log("HandleSuccesUserRegistration");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiRequestUserRegistrationAsyncSucces?.Invoke(resultInfo);
        }
        private void HandleFailedUserRegistration(string result)
        {
            UnityEngine.Debug.Log("HandleFailedUserRegistration");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiRequestUserRegistrationAsyncFailed?.Invoke(resultInfo);
        }

        private void HandleSuccesAdminRegistration(string result)
        {
            UnityEngine.Debug.Log("HandleSuccesAdminRegistration");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiRequestAdminRegistrationAsyncSucces?.Invoke(resultInfo);
        }

        private void HandleFailedAdminRegistration(string result)
        {
            UnityEngine.Debug.Log("HandleFailedAdminRegistration");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiRequestAdminRegistrationAsyncFailed?.Invoke(resultInfo);
        }

        private void HandleSuccesProcessPointFile(string result)
        {
            UnityEngine.Debug.Log("HandleSuccesProcessPointFile");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiPostProcessPointFileAsyncSucces?.Invoke(resultInfo);
        }

        private void HandleFailedProcessPointFile(string result)
        {
            UnityEngine.Debug.Log("HandleFailedProcessPointFile");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiPostProcessPointFileAsyncFailed?.Invoke(resultInfo);
        }

        private void HandleSuccesGetCityPoints(string result)
        {
            //TODO this api always return only ONE EXACTLY CITY, so we should invoke NOT A LIST, BUT A CITY;
            UnityEngine.Debug.Log("HandleSuccesGetCityPoints");
            var resultInfo = _parseService.ParseRawResponseTo<List<TouristlCityData>>(result);
            OnInternalApiPostGetCityPointsAsyncSucces?.Invoke(resultInfo);
        }
        private void HandleFailedGetCityPoints(string result)
        {
            UnityEngine.Debug.Log("HandleFailedGetCityPoints");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiPostGetCityPointsAsyncFailed?.Invoke(resultInfo);
        }
        private void HandleSuccesPutUploadFile(string result)
        {
            UnityEngine.Debug.Log("HandleSuccesPutUploadFile");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiPutUploadFileAsyncSucces?.Invoke(resultInfo);
        }
        private void HandleFailedPutUploadFile(string result)
        {
            UnityEngine.Debug.Log("HandleFailedPutUploadFile");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiPutUploadFileAsyncFailed?.Invoke(resultInfo);
        }
        private void HandleSuccesGetPicture(Texture2D picture, string fullFilePath)
        {
            UnityEngine.Debug.Log("HandleSuccesGetPicture");
            _fileService.SaveFile(picture.EncodeToJPG(), fullFilePath);
            OnInternalApiGetPictureAndCasheAsyncSucces?.Invoke(picture, fullFilePath);
        }
        private void HandleFailedGetPicture(string result)
        {
            UnityEngine.Debug.Log("HandleFailedGetPicture");
            var resultInfo = _parseService.ParseRawResponseTo<string>(result);
            OnInternalApiGetPictureAndCasheAsyncFailed?.Invoke(resultInfo);
        }
        #endregion
    }
}