using Newtonsoft.Json;
using System;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;

namespace NKC_SDK
{
    public class NKC
    {
        #region utils comunicazione HTTP


        /// <summary>
        /// Effettua chiamata URL e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <returns></returns>
        public static string callUrl(string URL)
        {
            string answ = "";
            var client = new WebClientWT();
            //var client = new WebClient();
            client.Headers.Add("user-agent", "NKC_SDK");
            try
            {
                answ = client.DownloadString(URL);
            }
            catch (Exception exc)
            {
                Log.Instance.Error($"Eccezione durante callUrl per URL: {URL}{Environment.NewLine}{exc}");
                answ = exc.Message;
            }
            // restituisco valore!
            return answ;
        }
        /// <summary>
        /// Effettua chiamata URL e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="payload"></param>
        /// <returns></returns>
        public static string callUrl(string URL, string payload)
        {
            string answ = "";
            var client = new WebClientWT();
            client.Headers.Add("user-agent", "NKC_SDK");
            try
            {
                answ = client.UploadString(URL, payload);
            }
            catch (Exception exc)
            {
                Log.Instance.Error($"Eccezione durante callUrl per URL: {URL} | payload: {payload}{Environment.NewLine}{exc}");
                answ = exc.Message;
            }
            // restituisco valore!
            return answ;
        }

        /// <summary>
        /// Effettua chiamata PUT
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="payload"></param>
        /// <returns></returns>
        public static string putData(string URL, string payload)
        {
            string answ = "";
            var client = new WebClientWT();
            client.Headers.Add("user-agent", "NKC_SDK");
            // importante x evitare errore 415 di dataType non ammesso
            client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
            try
            {
                // va messo "PUT" e va configurato IIS per accettare PUT
                answ = client.UploadString(URL, "PUT", payload);
                answ = "ok";
            }
            catch (Exception exc)
            {
                Log.Instance.Error($"Eccezione durante putData per {URL}{Environment.NewLine}{exc}");
                answ = exc.Message;
            }
            // restituisco valore!
            return answ;
        }


        #endregion

        #region URL di base

        protected string urlAlive
        {
            get
            {
                return $"{_baseUrl}api/Alive";
            }
        }
        protected string urlAliveClock
        {
            get
            {
                return $"{_baseUrl}api/Alive/1";
            }
        }
        protected string urlCurrBunk
        {
            get
            {
                return $"{_baseUrl}api/Bunk";
            }
        }
        protected string urlCurrSheet4Mac
        {
            get
            {
                return $"{_baseUrl}api/Sheet/{_codPost}";
            }
        }
        protected string urlGetBunk(int currBunkId)
        {
            return $"{_baseUrl}api/Bunk/{currBunkId}?showNext=false";
        }
        protected string urlNextBunk(int currBunkId)
        {
            return $"{_baseUrl}api/Bunk/{currBunkId}?showNext=true";
        }
        protected string urlPutBunk(int currBunkId)
        {
            return $"{_baseUrl}api/Bunk/{currBunkId}";
        }
        /// <summary>
        /// URL x salvataggio dati SHEET
        /// </summary>
        /// <returns></returns>
        protected string urlPutSheetList
        {
            get
            {
                return $"{_baseUrl}api/Sheet/{_codPost}";
            }
        }
        /// <summary>
        /// file locale per persistenza BUNK
        /// </summary>
        protected string persistFileName = "data/persistFile.json";

        #endregion

        /// <summary>
        /// URL di base per la comunicazione
        /// 
        /// PROD: http://seriate.steamware.net:8083/NKC/
        /// DEV:  https://localhost:44388/
        /// </summary>
        protected string _baseUrl { get; set; } = @"http://seriate.steamware.net:8083/NKC/";
        /// <summary>
        /// DnsName/IP di base x chaimate
        /// </summary>
        protected string _baseIp { get; set; } = "seriate.steamware.net";
        /// <summary>
        /// COD macchina x cui si effettua chiamata
        /// </summary>
        protected string _codPost { get; set; } = "";

        /// <summary>
        /// Classe per effettuare comunicazioni con NKC
        /// </summary>
        /// <param name="baseIp">IP di base x ping</param>
        /// <param name="baseUrl">URL di abse x chiamate REST</param>
        /// <param name="codPost">Codice posstazione/macchina x cui si fa chiamata</param>
        public NKC(string baseIp, string baseUrl, string codPost)
        {
            _baseIp = baseIp;
            _baseUrl = baseUrl;
            _codPost = codPost;
        }
        /// <summary>
        /// Effettua test ping all'indirizzo del server
        /// </summary>
        public PingReply testPing
        {
            get
            {
                Ping myPing = new Ping();
                // timeout a 1 sec!
                PingReply answ = myPing.Send(_baseIp, 1000);
                // rendo!
                return answ;
            }
        }
        /// <summary>
        /// Effettua test alive all'indirizzo del server
        /// </summary>
        public bool testAlive
        {
            get
            {
                bool answ = false;
                string returnData = callUrl(urlAlive);
                returnData = JsonConvert.DeserializeObject<string>(returnData);
                answ = returnData == "OK";
                // rendo!
                return answ;
            }
        }
        /// <summary>
        /// Effettua test ping all'indirizzo del server
        /// </summary>
        public DateTime testClock
        {
            get
            {
                DateTime oggi = DateTime.Today;
                DateTime answ = oggi.AddYears(-oggi.Year + 1900).AddMonths(-oggi.Month).AddDays(-oggi.Day + 1);
                // recupero!
                string returnData = callUrl(urlAliveClock);
                try
                {
                    DateTime.TryParse(JsonConvert.DeserializeObject<string>(returnData), out answ);
                }
                catch (Exception exc)
                {
                    Log.Instance.Error($"Eccezione durante testClock, ricevuto {returnData}{Environment.NewLine}{exc}");
                }
                // rendo!
                return answ;
            }
        }

        #region metodi per SheetWorklist

        /// <summary>
        /// Recupera elenco dei fogli ATTIVI
        /// - effettua chiamata tramite REST API HTTP
        /// - il risutlato viene deserializzato nell'oggetto richiesto
        /// </summary>
        /// <returns></returns>
        public SheetWorkList getCurrentSheets()
        {
            SheetWorkList answ = null;
            string rawdata = "";
            // chiamo metodo x recupero WBunk...
            try
            {
                rawdata = callUrl(urlCurrSheet4Mac);
                answ = JsonConvert.DeserializeObject<SheetWorkList>(rawdata);
            }
            catch (Exception exc)
            {
                Log.Instance.Error($"Eccezione durante getCurrentSheets, ricevuto {rawdata}{Environment.NewLine}{exc}");
            }
            return answ;
        }
        /// <summary>
        /// Effettua salvataggio dell'elenco dei fogli (1..n) su NKC
        /// </summary>
        /// <param name="updatedSheetList"></param>
        public bool saveSheets(SheetWorkList updatedSheetList)
        {
            bool answ = false;
            string rawdata = "";
            try
            {
                // serializzo oggetto
                rawdata = JsonConvert.SerializeObject(updatedSheetList);
                // invio con metodo put!
                putData(urlPutSheetList, rawdata);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Instance.Error($"Eccezione durante saveSheets, ricevuto {rawdata}{Environment.NewLine}{exc}");
            }
            return answ;
        }
        /// <summary>
        /// Oggetto che contiene l'oggetto SHEET WorkList corrente salvato LOCALMENTE
        /// </summary>
        public SheetWorkList persistedSheetList
        {
            get
            {
                SheetWorkList answ = new SheetWorkList();
                try
                {
                    string rawdata = File.ReadAllText(persistFileName);
                    answ = JsonConvert.DeserializeObject<SheetWorkList>(rawdata);
                }
                catch (Exception exc)
                {
                    Log.Instance.Error($"Eccezione durante recupero locale della SheetList{Environment.NewLine}{exc}");
                }
                return answ;
            }
            set
            {
                try
                {
                    // serializzo oggetto
                    string rawdata = JsonConvert.SerializeObject(value);
                    // salvo in locale
                    File.WriteAllText(persistFileName, rawdata);
                }
                catch (Exception exc)
                {
                    Log.Instance.Error($"Eccezione durante salvataggio locale della SheetList{Environment.NewLine}{exc}");
                }
            }
        }

        #endregion

#if false
        #region metodi per BUNK

    /// <summary>
    /// Recupera il PRIMO BUNK
    /// - effettua chiamata tramite REST API HTTP
    /// - il risutlato viene deserializzato nell'oggetto richiesto
    /// </summary>
    /// <returns></returns>
    public ProdBunk getFirstBunk()
    {
      ProdBunk answ = null;
      string rawdata = "";
      // chiamo metodo x recupero WBunk...
      try
      {
        rawdata = callUrl(urlCurrBunk);
        answ = JsonConvert.DeserializeObject<ProdBunk>(rawdata);
      }
      catch (Exception exc)
      {
        Log.Instance.Error($"Eccezione durante getFirstBunk, ricevuto {rawdata}{Environment.NewLine}{exc}");
      }
      return answ;
    }
    /// <summary>
    /// Recupera il BUNK SUCCESSIVO
    /// - effettua chaimata tramite REST API HTTP
    /// - il risutlato viene deserializzato nell'oggetto richiesto
    /// </summary>
    /// <returns></returns>
    public ProdBunk getNextBunk(int currBunkId)
    {
      ProdBunk answ = null;
      string rawdata = "";
      // chiamo metodo x recupero WBunk...
      try
      {
        rawdata = callUrl(urlNextBunk(currBunkId));
        answ = JsonConvert.DeserializeObject<ProdBunk>(rawdata);
      }
      catch (Exception exc)
      {
        Log.Instance.Error($"Eccezione durante getNextBunk, ricevuto {rawdata}{Environment.NewLine}{exc}");
      }
      return answ;
    }
    /// <summary>
    /// Recupera UN BUNK esatto
    /// - effettua chaimata tramite REST API HTTP
    /// - il risutlato viene deserializzato nell'oggetto richiesto
    /// </summary>
    /// <returns></returns>
    public ProdBunk getBunk(int currBunkId)
    {
      ProdBunk answ = null;
      string rawdata = "";
      // chiamo metodo x recupero WBunk...
      try
      {
        rawdata = callUrl(urlGetBunk(currBunkId));
        answ = JsonConvert.DeserializeObject<ProdBunk>(rawdata);
      }
      catch (Exception exc)
      {
        Log.Instance.Error($"Eccezione durante getBunk, ricevuto {rawdata}{Environment.NewLine}{exc}");
      }
      return answ;
    }
    /// <summary>
    /// Effettua salvataggio del BUNK corrente su NKC
    /// </summary>
    /// <param name="currBunk"></param>
    public bool saveBunk(ProdBunk currBunk)
    {
      bool answ = false;
      string rawdata = "";
      try
      {
        // serializzo oggetto
        rawdata = JsonConvert.SerializeObject(currBunk);
        // invio con metodo put!
        putData(urlPutBunk(currBunk.BunkId), rawdata);
        answ = true;
      }
      catch (Exception exc)
      {
        Log.Instance.Error($"Eccezione durante saveBunk, ricevuto {rawdata}{Environment.NewLine}{exc}");
      }
      return answ;
    }
    /// <summary>
    /// Oggetto che contiene il BUNK corrente LOCALMENTE
    /// </summary>
    public ProdBunk persistedBunk
    {
      get
      {
        ProdBunk answ = new ProdBunk();
        try
        {
          string rawdata = File.ReadAllText(persistFileName);
          answ = JsonConvert.DeserializeObject<ProdBunk>(rawdata);
        }
        catch (Exception exc)
        {
          Log.Instance.Error($"Eccezione durante recupero locale del bunk{Environment.NewLine}{exc}");
        }
        return answ;
      }
      set
      {
        try
        {
          // serializzo oggetto
          string rawdata = JsonConvert.SerializeObject(value);
          // salvo in locale
          File.WriteAllText(persistFileName, rawdata);
        }
        catch (Exception exc)
        {
          Log.Instance.Error($"Eccezione durante salvataggio locale del BUNK{Environment.NewLine}{exc}");
        }
      }
    }

        #endregion
#endif

    }
}