using MConnectSDK;
using QRCoder;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TestClient
{
    public partial class MainForm : Form
    {
        #region Private Fields

        /// <summary>
        /// Context x sync thread
        /// </summary>
        private readonly SynchronizationContext synchronizationContext;

        /// <summary>
        /// Token x cancellazione thread
        /// </summary>
        private CancellationTokenSource _cts;

        /// <summary>
        /// Timestamp precedente
        /// </summary>
        private DateTime previousTime = DateTime.Now;

        #endregion Private Fields

        #region Protected Fields

        /// <summary>
        /// Istanze classe MaestroConnectClient
        /// </summary>
        protected MConnectClient MCC;

        /// <summary>
        /// Risposta BASE della classe di comunicazione
        /// </summary>
        protected Result reqStatus;

        #endregion Protected Fields

        #region Public Constructors

        /// <summary>
        /// Form principale
        /// </summary>
        public MainForm()
        {
            InitializeComponent();
            myInit();
            synchronizationContext = SynchronizationContext.Current;
        }

        #endregion Public Constructors

        #region Protected Properties

        /// <summary>
        /// Password digitata
        /// </summary>
        protected string passwd
        {
            get
            {
                return txtPwd.Text.Trim();
            }
        }

        /// <summary>
        /// Username digitato
        /// </summary>
        protected string username
        {
            get
            {
                return txtUser.Text.Trim();
            }
        }

        #endregion Protected Properties

        #region Private Methods

        private async void btnDeleteUser_Click(object sender, EventArgs e)
        {
            await Task.Run(() =>
            {
                var taskResult = MCC.setUserImported(SourceType.LOCAL, username, false);
                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              refreshRequestStatus();
          }), "");
            });
        }

        private async void btnDeleteUserCloud_Click(object sender, EventArgs e)
        {
            await Task.Run(() =>
            {
                var taskResult = MCC.setUserImported(SourceType.CLOUD, username, false);
                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              refreshRequestStatus();
          }), "");
            });
        }

        private void btnFakeQR_Click(object sender, EventArgs e)
        {
            // testing di generazione QRCODE....
            string usr_cod = "GJU17-2DCH";
            string mach_id = "cjtfprjdv00i40xm76xmgu0ba";
            string fullString = string.Format("https://stg.maestroconnect.scmgroup.com/scm/settings/machine-settings/?nav=activation&user_code={0}&machineID=", usr_cod, mach_id);

            QRCodeGenerator qrGenerator = new QRCodeGenerator();
            QRCodeData qrCodeData = qrGenerator.CreateQrCode(fullString, QRCodeGenerator.ECCLevel.Q);
            QRCode qrCode = new QRCode(qrCodeData);
            Bitmap qrCodeImage = qrCode.GetGraphic(5);

            pictBox.Image = qrCodeImage;
        }

        private void btnFlush_Click(object sender, EventArgs e)
        {
            MCC.forceRedisFlush();
            MCC = null;
            fixDisplay();
        }

        private async void btnGetClientStatus_Click(object sender, EventArgs e)
        {
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var retObj = getClientStatus();
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | ClientStatus requested", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
        }

        private void btnGetLic_Click(object sender, EventArgs e)
        {
            var result = MCC.GetLicenseMConnect();
        }

        /// <summary>
        /// recupera codice organizzazione
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnGetOrgCode_Click(object sender, EventArgs e)
        {
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var retObj = getOrgCode();
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | OrgCode requested", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
        }

        private async void btnGetUserCreatedList_Click(object sender, EventArgs e)
        {
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var retObj = getUserListCreated();
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | UserList CREATED requested", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
        }

        /// <summary>
        /// chiamata recupero elenco utenti
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnGetUserList_Click(object sender, EventArgs e)
        {
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var retObj = getUserList();
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | UserList requested", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
        }

        private async void btnImportUser_Click(object sender, EventArgs e)
        {
            await Task.Run(() =>
            {
                var taskResult = MCC.setUserImported(SourceType.LOCAL, username, true);
                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              refreshRequestStatus();
          }), "");
            });
        }

        /// <summary>
        /// Simulazione INIT
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnInit_Click(object sender, EventArgs e)
        {
            // reset x iniziare...
            if (_cts != null)
            {
                _cts.Cancel();
            }
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var initObj = doInitAsync(txtConfFile.Text.Trim());
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | START INIT", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
            // resetto aspetti grafici
            resetAuthData();
        }

        /// <summary>
        /// Reset parametri...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnResetParam_Click(object sender, EventArgs e)
        {
            txtConfFile.Text = "mconnect.conf.yaml";
            txtUploadFile.Text = "file2upload.zip";
            reqStatus = new Result();
            lblReqStatus.Text = "";
            lblConsole.Text = "";
            fixDisplay();
        }

        private async void btnStartClient_Click(object sender, EventArgs e)
        {
#if false
            // reset x iniziare...
            if (_cts != null)
            {
                _cts.Cancel();
            }
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var initObj = doGetStatusAsync();
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | START INIT", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
            // resetto aspetti grafici
            resetAuthData();
#endif
        }

        /// <summary>
        /// Simulazione AUTH
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnTryAuth_Click(object sender, EventArgs e)
        {
            // init variabili accessorie x chiamata
            StringBuilder sb = new StringBuilder();
            // elimino eventuali cancel presenti...
            if (_cts.IsCancellationRequested)
            {
                _cts = new CancellationTokenSource();
            }
            CancellationToken token = _cts.Token;
            // gestione progress...
            var progressHandler = new Progress<Result>(value =>
            {
                // aggiorno richiesta live...
                reqStatus = value;
                refreshRequestStatus();
                // mostro i dati SPECIFICI x AUTH...
                updateAuthData((ActivationPayload)value.Payload);
            });
            var progress = progressHandler as IProgress<Result>;

            try
            {
                // init in modalità Task based AUTH...
                await Task.Run(() =>
                {
                    var initObj = MCC.TryActivationAsync(token, progress);
                    // recupero dati e aggiorno display...
                    var taskResult = MCC.GetClientStatusAsync();
                    // salvo il risultato restituito...
                    reqStatus = taskResult.Result;
                    // aggiorno display
                    synchronizationContext.Post(new SendOrPostCallback(o =>
                    {
                        refreshRequestStatus();
                    }), "");
                });
            }
            catch (OperationCanceledException)
            {
                sb = new StringBuilder();
                sb.AppendLine("--------------------------------------------------");
                sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | CANCELLED OAuth process", DateTime.Now));
                sb.AppendLine("--------------------------------------------------");
                lblConsole.Text = sb.ToString();
            }
            catch
            {
                //label2.Text = ex.GetType().Name + ": " + ex.Message;
            }

            // aggiorno log console
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | STARTING OAuth process", DateTime.Now));
            sb.AppendLine("--------------------------------------------------");
            lblConsole.Text = sb.ToString();
        }

        /// <summary>
        /// Simulazione ENROLL
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnTryEnroll_Click(object sender, EventArgs e)
        {
            // init variabili accessorie x chiamata
            StringBuilder sb = new StringBuilder();
            // elimino eventuali cancel presenti...
            if (_cts.IsCancellationRequested)
            {
                _cts = new CancellationTokenSource();
            }
            CancellationToken token = _cts.Token;
            // gestione progress...
            var progressHandler = new Progress<Result>(value =>
            {
                // aggiorno richeista live...
                reqStatus = value;
                refreshRequestStatus();
                // mostro i dati SPECIFICI x AUTH...
                updateAuthData((ActivationPayload)value.Payload);
            });
            var progress = progressHandler as IProgress<Result>;

            try
            {
                // init in modalità Task based AUTH...
                await Task.Run(() =>
                {
                    var initObj = MCC.EnrollMachineAsync(token, progress);
                    // recupero dati e aggiorno display...
                    var taskResult = MCC.GetClientStatusAsync();
                    // salvo il risultato restituito...
                    reqStatus = taskResult.Result;
                    // aggiorno display
                    synchronizationContext.Post(new SendOrPostCallback(o =>
                    {
                        refreshRequestStatus();
                    }), "");
                });
            }
            catch (OperationCanceledException)
            {
                sb = new StringBuilder();
                sb.AppendLine("--------------------------------------------------");
                sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | CANCELLED ENROLL process", DateTime.Now));
                sb.AppendLine("--------------------------------------------------");
                lblConsole.Text = sb.ToString();
            }
            catch
            {
                //label2.Text = ex.GetType().Name + ": " + ex.Message;
            }

            // aggiorno log console
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | STARTING ENROLL process", DateTime.Now));
            sb.AppendLine("--------------------------------------------------");
            lblConsole.Text = sb.ToString();
        }

        /// <summary>
        /// chiamata x login utente
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnTryUserLogin_Click(object sender, EventArgs e)
        {
            // init in modalità Task based...
            await Task.Run(() =>
            {
                var retObj = doUserLogin(username, passwd);
            });

            // aggiorno log console
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("--------------------------------------------------");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | UserLogin requested", DateTime.Now));
            sb.AppendLine("");
            lblConsole.Text = sb.ToString();
        }

        private async void btnUploadFile_Click(object sender, EventArgs e)
        {
            string startTime = $"Fileupload: start {DateTime.Now}{Environment.NewLine}";
            synchronizationContext.Post(new SendOrPostCallback(o =>
            {
                lblConsole.Text = startTime;
            }), "");
            // elimino eventuali cancel presenti...
            if (_cts.IsCancellationRequested)
            {
                _cts = new CancellationTokenSource();
            }
            CancellationToken token = _cts.Token;
            // gestione progress...
            var progressHandler = new Progress<Result>(value =>
            {
                // aggiorno richeista live...
                reqStatus = value;
                refreshRequestStatus();
                // mostro i dati SPECIFICI x AUTH...
                updateAuthData((ActivationPayload)value.Payload);
            });
            var progress = progressHandler as IProgress<Result>;

            await Task.Run(() =>
            {
                var taskResult = MCC.TryUpLoadFile(token, progress, txtUploadFile.Text.Trim());

                try
                {
                    // salvo il risultato restituito...
                    reqStatus = taskResult.Result;
                }
                catch (Exception exc)
                {
                    MConnectSDK.Log.Instance.Error(exc, "Eccezione in btnUploadFile_Click");
                }

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              lblConsole.Text = startTime;
              refreshRequestStatus();
          }), "");
            });
        }

        /// <summary>
        /// Task x get status
        /// </summary>
        /// <returns></returns>
        private async Task doGetStatusAsync()
        {
#if false
            // attendo init...
            await Task.Run(() =>
            {
                // NUOVA istanza da file di conf...
                MCC = new MConnectClient();

                // init async...
                var taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);

                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("InitSDKAsync");
                    sb.AppendLine("--------------------------------------------------");
                    lblConsole.Text = sb.ToString();
                    refreshRequestStatus();
                }), "");
            });
#endif
            // ora attendo get client...
            await Task.Run(() =>
            {
                // init async...
                var taskResult = MCC.GetClientStatusAsync();

                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("GetClientStatusAsync");
                    sb.AppendLine("--------------------------------------------------");
                    lblConsole.Text = sb.ToString();
                    refreshRequestStatus();
                }), "");
            });
            // ora attendo get client...
            await Task.Run(() =>
            {
                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    fixDisplay();
                }), "");
            });
        }

        /// <summary>
        /// Task x INIT da file di conf
        /// </summary>
        /// <param name="confFilePath"></param>
        /// <returns></returns>
        private async Task doInitAsync(string confFilePath)
        {
            // attendo init...
            await Task.Run(() =>
            {
                // NUOVA istanza da file di conf...
                MCC = new MConnectClient();

                // init async...
                var taskResult = MCC.InitSDKAsync(confFilePath, CancellationToken.None);

                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("InitSDKAsync");
                    sb.AppendLine("--------------------------------------------------");
                    lblConsole.Text = sb.ToString();
                    refreshRequestStatus();
                }), "");
            });
#if false
            // ora attendo get client...
            await Task.Run(() =>
            {
                // init async...
                var taskResult = MCC.GetClientStatusAsync();

                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("GetClientStatusAsync");
                    sb.AppendLine("--------------------------------------------------");
                    lblConsole.Text = sb.ToString();
                    refreshRequestStatus();
                }), "");
            });
#endif
            // ora attendo risposta...
            await Task.Run(() =>
            {
                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    fixDisplay();
                }), "");
            });
        }

        /// <summary>
        /// Tento login utente
        /// </summary>
        /// <returns></returns>
        private async Task doUserLogin(string user, string pwd)
        {
            StringBuilder sb;
            await Task.Run(() =>
            {
                UserData userData = new UserData();
                var userResult = MCC.TryUserLogin(user, pwd);
                userResult.Wait();
                var currImage = pictBox.Image;

                //if (userData.Username != "")
                if (userResult.Result.Error.Reason == UserReason.AllOk)
                {
                    List<UserData> userList = ((UserPayload)userResult.Result.Payload).UserList;
                    // controllo se ho risultato...)
                    if (userList.Count == 1)
                    {
                        userData = userList[0];
                    }
                    sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("USER AUTH OK");
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("");
                    sb.AppendLine(string.Format("user_id: {0}", userData.UserId));
                    sb.AppendLine(string.Format("isAdmin: {0}", userData.IsAdmin));
                    sb.AppendLine(string.Format("UserName: {0}", userData.Username));
                    sb.AppendLine(string.Format("Email: {0}", userData.Email));
                    sb.AppendLine(string.Format("Cognome: {0}", userData.Cognome));
                    sb.AppendLine(string.Format("Nome: {0}", userData.Nome));
                    sb.AppendLine(string.Format("Status: {0}", userList[0].LoginStatus.ToString()));
                    // aggiungo IMG user... se vuota default...
                    if (userList[0].UserImage == null)
                    {
                        userList[0].UserImage = Image.FromFile(@"resources\userImg.png");
                    }
                    currImage = userList[0].UserImage;
                }
                else
                {
                    sb = new StringBuilder();
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("USER AUTH KO");
                    sb.AppendLine("--------------------------------------------------");
                    sb.AppendLine("");
                    sb.AppendLine($"ERROR: {userResult.Result.Error.Reason}");
                    sb.AppendLine($"Message: {userResult.Result.Error.message}");
                    sb.AppendLine("User/Pwd NOT found");
                }

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              pictBox.Image = currImage;
              lblConsole.Text = sb.ToString();
              refreshRequestStatus();
          }), "");
            });
        }

        private void fixDisplay()
        {
            // mostro init SOLO SE ho conf yaml...
            btnInit.Enabled = txtConfFile.Text.Trim() != "";
            // verifico SE ho inizializzato x cui POSSO mostrare alcuni buttons...
            bool enableBtn = (MCC != null);
            btnFlush.Enabled = enableBtn;
            btnTryAuth.Enabled = enableBtn;
            btnTryEnroll.Enabled = enableBtn;
            btnGetClientStatus.Enabled = enableBtn;
            btnGetOrgCode.Enabled = enableBtn;
            btnGetUserList.Enabled = enableBtn;
            btnTryUserLogin.Enabled = enableBtn;
            btnGetUserCreatedList.Enabled = enableBtn;
            btnImportUser.Enabled = enableBtn;
            btnDeleteUserHMI.Enabled = enableBtn;
            btnGetLic.Enabled = enableBtn;

            // controllo se visualizzare parametri di testing...
            if (reqStatus != null)
            {
                // se NON enrolled --> abilita tryAuth...
                btnTryAuth.Enabled = !reqStatus.IsAuth;
                btnTryEnroll.Enabled = !reqStatus.IsHmiEnrolled;
            }
        }

        /// <summary>
        /// Recupero client status
        /// </summary>
        /// <returns></returns>
        private async Task getClientStatus()
        {
            await Task.Run(() =>
            {
                var taskResult = MCC.GetClientStatusAsync();
                // salvo il risultato restituito...
                reqStatus = taskResult.Result;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              StringBuilder sb = new StringBuilder();
              sb.AppendLine("--------------------------------------------------");
              sb.AppendLine("CLIENT INFO DATA REFRESHED");
              sb.AppendLine("--------------------------------------------------");
              lblConsole.Text = sb.ToString();
              refreshRequestStatus();
          }), "");
            });
        }

        /// <summary>
        /// Recupero OrgCode
        /// </summary>
        /// <returns></returns>
        private async Task getOrgCode()
        {
            await Task.Run(() =>
            {
                string orgCode = MCC.organizationCode;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              StringBuilder sb = new StringBuilder();
              sb.AppendLine("--------------------------------------------------");
              sb.AppendLine("ORGANIZATION CODE: " + orgCode);
              sb.AppendLine("--------------------------------------------------");
              lblConsole.Text = sb.ToString();

              refreshRequestStatus();
          }), "");
            });
        }

        /// <summary>
        /// Recupero UserList
        /// </summary>
        /// <returns></returns>
        private async Task getUserList()
        {
            await Task.Run(() =>
            {
                var userResult = MCC.getUserListAsync(chkGetImg.Checked);
                List<UserData> userList = ((UserPayload)userResult.Result.Payload).UserList;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              StringBuilder sb = new StringBuilder();
              sb.AppendLine("--------------------------------------------------");
              sb.AppendLine("USERS FOUND: " + userList.Count.ToString());
              sb.AppendLine("--------------------------------------------------");
              if (userList.Count > 0)
              {
                  sb.AppendLine("first user::");
                  sb.AppendLine(string.Format("user_id: {0}", userList[0].UserId));
                  sb.AppendLine(string.Format("isAdmin: {0}", userList[0].IsAdmin));
                  sb.AppendLine(string.Format("UserName: {0}", userList[0].Username));
                  sb.AppendLine(string.Format("Email: {0}", userList[0].Email));
                  sb.AppendLine(string.Format("Cognome: {0}", userList[0].Cognome));
                  sb.AppendLine(string.Format("Nome: {0}", userList[0].Nome));
                  sb.AppendLine(string.Format("Status: {0}", userList[0].LoginStatus.ToString()));
                  // aggiungo IMG user... se vuota default...
                  if (userList[0].UserImage == null)
                  {
                      userList[0].UserImage = Image.FromFile(@"resources\userImg.png");
                  }
                  pictBox.Image = userList[0].UserImage;
                  lblConsole.Text = sb.ToString();
              }
              // refresh!
              refreshRequestStatus();
          }), "");
            });
        }

        /// <summary>
        /// Recupero UserList che risultano CREATI sulal piattaforma MConnect e su HMI
        /// </summary>
        /// <returns></returns>
        private async Task getUserListCreated()
        {
            await Task.Run(() =>
            {
                var userResult = MCC.getUserImportedListAsync();
                userResult.Wait();
                List<UserData> userList = ((UserPayload)userResult.Result.Payload).UserList;

                synchronizationContext.Post(new SendOrPostCallback(o =>
          {
              StringBuilder sb = new StringBuilder();
              sb.AppendLine("--------------------------------------------------");
              sb.AppendLine("USERS CREATED FOUND: " + userList.Count.ToString());
              sb.AppendLine("--------------------------------------------------");
              if (userList.Count > 0)
              {
                  sb.AppendLine("first user:");
                  sb.AppendLine(string.Format("user_id: {0}", userList[0].UserId));
                  sb.AppendLine(string.Format("isAdmin: {0}", userList[0].IsAdmin));
                  sb.AppendLine(string.Format("UserName: {0}", userList[0].Username));
                  sb.AppendLine(string.Format("Email: {0}", userList[0].Email));
                  sb.AppendLine(string.Format("Cognome: {0}", userList[0].Cognome));
                  sb.AppendLine(string.Format("Nome: {0}", userList[0].Nome));
                  sb.AppendLine(string.Format("Status: {0}", userList[0].LoginStatus.ToString()));
                  // aggiungo IMG user... se vuota default...
                  if (userList[0].UserImage == null)
                  {
                      userList[0].UserImage = Image.FromFile(@"resources\userImg.png");
                  }
                  pictBox.Image = userList[0].UserImage;
              }
              lblConsole.Text = sb.ToString();
              // refresh!
              refreshRequestStatus();
          }), "");
            });
        }

        private void LblMachineId_Click(object sender, EventArgs e)
        {
            Clipboard.SetText(lblMachineId.Text);
            MessageBox.Show("COPIED current MACHINE_ID to Clipboard!\r\n" + lblMachineId.Text, "MACHINE_ID ACQUIRED", MessageBoxButtons.OK);
        }

        private void lblUrl_Click(object sender, EventArgs e)
        {
            Clipboard.SetText(lblUrl.Text);
            MessageBox.Show("COPIED current AUTH URL to Clipboard!\r\n" + lblUrl.Text, "AUTH URL ACQUIRED", MessageBoxButtons.OK);
        }

        private void lblUserCode_Click(object sender, EventArgs e)
        {
            Clipboard.SetText(lblUserCode.Text);
            MessageBox.Show("COPIED current user_code to Clipboard!\r\n" + lblUserCode.Text, "USER_CODE ACQUIRED", MessageBoxButtons.OK);
        }

        private void resetAuthData()
        {
            Bitmap bitmap = new Bitmap(200, 200, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            using (Graphics graphics = Graphics.FromImage(bitmap))
            {
                using (System.Drawing.SolidBrush myBrush = new System.Drawing.SolidBrush(System.Drawing.Color.LightGray))
                {
                    graphics.FillRectangle(myBrush, new Rectangle(0, 0, 200, 200));
                }
            }
            // graphics will be disposed at this line
            pictBox.Image = bitmap;
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("RESET DATA done!");
            lblRetData.Text = sb.ToString();
        }

        /// <summary>
        /// Mostra info x USER AUTH
        /// </summary>
        /// <param name="authData"></param>
        private void updateAuthData(ActivationPayload authData)
        {
            // aggiorno console...
            lblConsole.Text = authData.Message;
            // verifico se sia AUTH (altrimenti NON mostro codice e QR...)
            if (authData.HasAuth || reqStatus.IsAuth)
            {
                var currColor = Color.Orange;
                // se fosse ANCHE enrolled cambio colore...
                if (authData.IsEnrolled || reqStatus.IsHmiEnrolled)
                {
                    currColor = Color.Green;
                }
                Bitmap bitmap = new Bitmap(200, 200, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                using (Graphics graphics = Graphics.FromImage(bitmap))
                {
                    using (SolidBrush myBrush = new SolidBrush(currColor))
                    {
                        graphics.FillRectangle(myBrush, new Rectangle(0, 0, 200, 200));
                    }
                }
                // graphics will be disposed at this line
                pictBox.Image = bitmap;
                StringBuilder sb = new StringBuilder();
                sb.AppendLine("AUTH DONE!");
                if (authData.IsEnrolled || reqStatus.IsHmiEnrolled)
                {
                    sb.AppendLine("------");
                    sb.AppendLine("ENROLLED!");
                }
                lblRetData.Text = sb.ToString();
            }
            else
            {
                // mostro info SE disponibili...
                if (authData.UserCode != null && authData.UserCode != "")
                {
                    // salvo in label specifica
                    lblUserCode.Text = authData.UserCode.ToString();
                    lblMachineId.Text = MCC.MachineID;
                    // salvo output
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("device_code:");
                    sb.AppendLine(authData.DeviceCode.ToString());
                    sb.AppendLine("");
                    sb.AppendLine("user_code:");
                    sb.AppendLine(authData.UserCode.ToString());
                    sb.AppendLine("");
                    lblRetData.Text = sb.ToString();

                    // genero QRCode
                    QRCodeGenerator qrGenerator = new QRCodeGenerator();
                    QRCodeData qrCodeData = qrGenerator.CreateQrCode(authData.QrCode, QRCodeGenerator.ECCLevel.Q);
                    QRCode qrCode = new QRCode(qrCodeData);
                    Bitmap qrCodeImage = qrCode.GetGraphic(5);
                    pictBox.Image = qrCodeImage;

                    // aggiungo link!
                    lblUrl.Text = authData.QrCode;
                }
            }
        }

        private async Task updateClockAsync()
        {
            await Task.Run(() =>
            {
                while (true)
                {
                    Thread.Sleep(50);
                    UpdateUI();
                }
            });
        }

        #endregion Private Methods

        #region Protected Methods

        protected void myInit()
        {
            var clockTask = updateClockAsync();
            _cts = new CancellationTokenSource();
            fixDisplay();
            lblConsole.Text = "";
        }

        #endregion Protected Methods

        #region Public Methods

        public void refreshRequestStatus()
        {
            // mostro risultato
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("-------------------------");
            sb.AppendLine("- Request Status");
            sb.AppendLine("-------------------------");
            if (reqStatus != null)
            {
                sb.AppendLine("isAuth: " + reqStatus.IsAuth);
                sb.AppendLine("isHmiEnrolled: " + reqStatus.IsHmiEnrolled);
                sb.AppendLine("cloudConnection: " + reqStatus.CloudStatusOk);
                sb.AppendLine("localConnection: " + reqStatus.LocalStatusOk);
                sb.AppendLine("callSuccess: " + reqStatus.CallResultOk);
                sb.AppendLine("");
                if (reqStatus.Payload != null)
                {
                    sb.AppendLine("message: " + reqStatus.Payload.Message);
                    sb.AppendLine("");
                    // se contiene risultato...
                    try
                    {
                        var fileUploadRes = (FilePayload)reqStatus.Payload;
                        if (fileUploadRes != null)
                        {
                            sb.AppendLine("file link: " + fileUploadRes.uploadResults.result.link);
                            sb.AppendLine("");
                        }
                    }
                    catch
                    { }
                    //if(reqStatus.Payload.)
                }
                sb.AppendLine(string.Format("{0:HH.mm.ss.fff}", DateTime.Now));
                sb.AppendLine("-------------------------");
            }
            lblReqStatus.Text = sb.ToString();
            sb.AppendLine("");
            sb.AppendLine(string.Format("{0:HH.mm.ss.fff} | END", DateTime.Now));
            sb.AppendLine("--------------------------------------------------");
            lblConsole.Text += sb.ToString();

            if (reqStatus != null)
            {
                // se NON enrolled --> abilita tryAuth...
                btnTryAuth.Enabled = !reqStatus.IsAuth;
                btnTryEnroll.Enabled = !reqStatus.IsHmiEnrolled;
            }
        }

        public void UpdateUI()
        {
            var timeNow = DateTime.Now;

            if ((DateTime.Now - previousTime).Milliseconds <= 250)
            {
                return;
            }

            try
            {
                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    lblClock.Text = timeNow.ToString("ddd dd.MM.yyyy HH:mm:ss");
                }), "");
            }
            catch
            { }
            previousTime = timeNow;
        }

        #endregion Public Methods
    }
}