using System;
using System.Collections.Generic;
using MediaTekDocuments.model;
using MediaTekDocuments.manager;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using System.Configuration;
using System.Linq;
using Serilog;

namespace MediaTekDocuments.dal
{
    /// <summary>
    /// Classe d'accès aux données
    /// </summary>
    public class Access
    {
        /// <summary>
        /// instance unique de la classe
        /// </summary>
        private static Access instance = null;
        /// <summary>
        /// instance de ApiRest pour envoyer des demandes vers l'api et recevoir la réponse
        /// </summary>
        private readonly ApiRest api = null;
        /// <summary>
        /// méthode HTTP pour select
        /// </summary>
        private const string GET = "GET";
        /// <summary>
        /// méthode HTTP pour insert
        /// </summary>
        private const string POST = "POST";
        /// <summary>
        /// méthode HTTP pour update
        /// 

        /// <summary>
        /// méthode HTTP pour delete
        /// </summary>
        private const string DELETE = "DELETE";

        /// <summary>
        /// Méthode privée pour créer un singleton
        /// initialise l'accès à l'API
        /// </summary>
        // Le constructeur redevient sans paramètre pour le Singleton
        private Access()
        {
            string authenticationString;
            string uriApi;

            Log.Logger = new LoggerConfiguration().MinimumLevel.Debug().WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Day).CreateLogger();

            try
            {
                uriApi = ConfigurationManager.AppSettings["ApiUri"];
                authenticationString = ConfigurationManager.AppSettings["ApiAuthentication"];
                api = ApiRest.GetInstance(uriApi, authenticationString);

                Log.Information("Log de : {NomMethode} : {Message}", nameof(Access), "Api instanciée");
            }
            catch (Exception e)
            {
                Log.Fatal(e, "Erreur fatale lors de l'initialisation de l'accès API");
                Environment.Exit(0);
            }
        }

        public static Access GetInstance()
        {
            if (instance == null)
            {
                // On appelle le constructeur sans argument
                instance = new Access();
            }
            return instance;
        }

        /// <summary>
        /// Retourne tous les genres à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Genre</returns>
        public List<Categorie> GetAllGenres()
        {
            IEnumerable<Genre> lesGenres = TraitementRecup<Genre>(GET, "genre", null);
            return new List<Categorie>(lesGenres);
        }

        /// <summary>
        /// Retourne tous les rayons à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Rayon</returns>
        public List<Categorie> GetAllRayons()
        {
            IEnumerable<Rayon> lesRayons = TraitementRecup<Rayon>(GET, "rayon", null);
            return new List<Categorie>(lesRayons);
        }

        /// <summary>
        /// Retourne toutes les catégories de public à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Public</returns>
        public List<Categorie> GetAllPublics()
        {
            IEnumerable<Public> lesPublics = TraitementRecup<Public>(GET, "public", null);
            return new List<Categorie>(lesPublics);
        }

        /// <summary>
        /// Retourne toutes les livres à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Livre</returns>
        public List<Livre> GetAllLivres()
        {
            List<Livre> lesLivres = TraitementRecup<Livre>(GET, "livre", null);
            return lesLivres;
        }

        /// <summary>
        /// Retourne toutes les dvd à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Dvd</returns>
        public List<Dvd> GetAllDvd()
        {
            List<Dvd> lesDvd = TraitementRecup<Dvd>(GET, "dvd", null);
            return lesDvd;
        }

        /// <summary>
        /// Retourne toutes les revues à partir de la BDD
        /// </summary>
        /// <returns>Liste d'objets Revue</returns>
        public List<Revue> GetAllRevues()
        {
            List<Revue> lesRevues = TraitementRecup<Revue>(GET, "revue", null);
            return lesRevues;
        }


        /// <summary>
        /// Retourne les exemplaires d'une revue
        /// </summary>
        /// <param name="idDocument">id de la revue concernée</param>
        /// <returns>Liste d'objets Exemplaire</returns>
        public List<Exemplaire> GetExemplairesRevue(string idDocument)
        {
            String jsonIdDocument = convertToJson("id", idDocument);
            List<Exemplaire> lesExemplaires = TraitementRecup<Exemplaire>(GET, "exemplaire/" + jsonIdDocument, null);
            return lesExemplaires;
        }

        /// <summary>
        /// ecriture d'un exemplaire en base de données
        /// </summary>
        /// <param name="exemplaire">exemplaire à insérer</param>
        /// <returns>true si l'insertion a pu se faire (retour != null)</returns>
        public bool CreerExemplaire(Exemplaire exemplaire)
        {
            String jsonExemplaire = JsonConvert.SerializeObject(exemplaire, new CustomDateTimeConverter());
            try
            {
                List<Exemplaire> liste = TraitementRecup<Exemplaire>(POST, "exemplaire", "champs=" + jsonExemplaire);
                return (liste != null);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Log.Error(ex, "Erreur dans {NomMethode} : {Message}", nameof(CreerExemplaire), ex.Message);
            }
            return false;
        }

        /// <summary>
        /// Traitement de la récupération du retour de l'api, avec conversion du json en liste pour les select (GET)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="methode">verbe HTTP (GET, POST, PUT, DELETE)</param>
        /// <param name="message">information envoyée dans l'url</param>
        /// <param name="parametres">paramètres à envoyer dans le body, au format "chp1=val1&chp2=val2&..."</param>
        /// <returns>liste d'objets récupérés (ou liste vide)</returns>
        private List<T> TraitementRecup<T> (String methode, String message, String parametres)
        {
            // trans
            List<T> liste = new List<T>();
            try
            {
                JObject retour = api.RecupDistant(methode, message, parametres);
                // extraction du code retourné
                String code = (String)retour["code"];
                if (code.Equals("200"))
                {
                    if (methode.Equals(GET))
                    {
                        String resultString = JsonConvert.SerializeObject(retour["result"]);
                        liste = JsonConvert.DeserializeObject<List<T>>(resultString, new CustomBooleanJsonConverter());
                    }
                }
                else
                {
                    Console.WriteLine("code erreur = " + code + " message = " + (String)retour["message"]);
                    Log.Warning("API Retourne une erreur - Code: {Code}, Message: {Message}", code, (string)retour["message"]);
                }
            }catch(Exception e)
            {
                Console.WriteLine("Erreur lors de l'accès à l'API : "+e.Message);
                Log.Error(e, "Erreur lors de l'accès à l'API via TraitementRecup");
                Environment.Exit(0);
            }
            return liste;
        }

        /// <summary>
        /// Convertit en json un couple nom/valeur
        /// </summary>
        /// <param name="nom"></param>
        /// <param name="valeur"></param>
        /// <returns>couple au format json</returns>
        private String convertToJson(Object nom, Object valeur)
        {
            Dictionary<Object, Object> dictionary = new Dictionary<Object, Object>();
            dictionary.Add(nom, valeur);
            return JsonConvert.SerializeObject(dictionary);
        }

        /// <summary>
        /// Modification du convertisseur Json pour gérer le format de date
        /// </summary>
        private sealed class CustomDateTimeConverter : IsoDateTimeConverter
        {
            public CustomDateTimeConverter()
            {
                base.DateTimeFormat = "yyyy-MM-dd";
            }
        }

        /// <summary>
        /// Modification du convertisseur Json pour prendre en compte les booléens
        /// classe trouvée sur le site :
        /// https://www.thecodebuzz.com/newtonsoft-jsonreaderexception-could-not-convert-string-to-boolean/
        /// </summary>
        private sealed class CustomBooleanJsonConverter : JsonConverter<bool>
        {
            public override bool ReadJson(JsonReader reader, Type objectType, bool existingValue, bool hasExistingValue, JsonSerializer serializer)
            {
                return Convert.ToBoolean(reader.ValueType == typeof(string) ? Convert.ToByte(reader.Value) : reader.Value);
            }

            public override void WriteJson(JsonWriter writer, bool value, JsonSerializer serializer)
            {
                serializer.Serialize(writer, value);
            }
        }

        /// <summary>
        /// Récupère les commandes d'un document (livre ou dvd)
        /// </summary>
        /// <param name="idDocument">ID du document concerné</param>
        /// <returns>Liste des commandes du document</returns>
        public List<CommandeDocument> GetCommandesDocument(string idDocument)
        {
            string jsonId = "{\"id\":\"" + idDocument + "\"}";
            List<CommandeDocument> lesCommandes = TraitementRecup<CommandeDocument>(GET, "commandelivre/" + jsonId, null);

            return lesCommandes;
        }

        public bool DeleteCommande(string idCommande)
        {

            String jsonIdCommande = convertToJson("id", idCommande);
            try
            {
                JObject retour = api.RecupDistant("DELETE", "commande/" + jsonIdCommande, null);
                return (retour["code"].ToString().Equals("200"));
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Erreur dans {NomMethode} : {Message}", nameof(DeleteCommande), ex.Message);
                return false;
            }
        }

        public List<Categorie> GetAllSuivis()
        {
            IEnumerable<Categorie> lesSuivis = TraitementRecup<Categorie>(GET, "suivi", null);
            return new List<Categorie>(lesSuivis);
        }

        public bool CreerCommande(CommandeDocument commande)
        {
            String jsonExemplaire = JsonConvert.SerializeObject(commande, new CustomDateTimeConverter());
            try
            {
                List<Exemplaire> liste = TraitementRecup<Exemplaire>(POST, "commandedocument", "champs=" + jsonExemplaire);
                return (liste != null);
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Erreur lors de la création de commande");
            }
            return false;
        }

        public string GetNextCommandeId()
        {
            List<dynamic> result = TraitementRecup<dynamic>(GET, "maxcommande", null);
            if (result != null && result.Count > 0)
            {
                var firstResult = result[0];
                if (firstResult != null && firstResult.maxId != null)
                {
                    string lastId = firstResult.maxId.ToString();
                    if (lastId.Length > 1)
                    {
                        int nextIdVal = int.Parse(lastId.Substring(1)) + 1;
                        return nextIdVal.ToString("D4");
                    }
                }
            }
            return "0001";
        }
        public bool UpdateSuiviCommande(string idCommande, string idSuivi)
        {
            String jsonSuivi = convertToJson("idSuivi", idSuivi);
            try
            {
                // Appel PUT : http://localhost/rest_mediatekdocuments/commandedocument/C0001
                JObject retour = api.RecupDistant("PUT", "commandedocument/" + idCommande, "champs=" + jsonSuivi);
                return (retour["code"].ToString().Equals("200"));
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Erreur dans {NomMethode} : {Message}", nameof(UpdateSuiviCommande), ex.Message);
                return false;
            }
        }

        public List<Abonnement> GetAbonnements(string idRevue)
        {
            string jsonIdRevue = convertToJson("id", idRevue);
            return TraitementRecup<Abonnement>(GET, "commanderevue/" + jsonIdRevue, null);
        }

        public bool CreerAbonnement(Abonnement abonnement)
        {
            string jsonAbonnement = JsonConvert.SerializeObject(abonnement, new CustomDateTimeConverter());
            try
            {
                JObject retour = api.RecupDistant(POST, "abonnement", "champs=" + jsonAbonnement);

                return retour["code"].ToString().Equals("200");
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Erreur dans {NomMethode} : {Message}", nameof(GetAbonnements), ex.Message);
                return false;
            }
        }

        public bool SupprimerAbonnement(string idAbonnement)
        {
            string jsonId = convertToJson("id", idAbonnement);
            try
            {
                JObject retour = api.RecupDistant(DELETE, "abonnement/" + jsonId, null);
                return retour["code"].ToString().Equals("200");
            }
            catch(Exception ex) {
                Log.Error(ex, "Erreur dans {NomMethode} : {Message}", nameof(SupprimerAbonnement), ex.Message);
                return false;
            }
        }

        public Utilisateur GetConnection(string login, string pwd)
        {
            Dictionary<string, string> loginInfo = new Dictionary<string, string>
            {
                { "identifiant", login },
                { "motDePasse", pwd }
            };

            string jsonLogin = JsonConvert.SerializeObject(loginInfo);
            List<Utilisateur> lesUtilisateurs = TraitementRecup<Utilisateur>(GET, "utilisateur/" + jsonLogin, null);

            if (lesUtilisateurs != null && lesUtilisateurs.Count > 0)
            {
                return lesUtilisateurs[0];
            }
            Log.Warning("Tentative de connexion échouée pour le login : {Login}", login);
            return null;
        }
    }
}