using CMS_SC_Data;
using SteamWare;
using System;
using System.Linq;
using System.Web;
using System.Web.UI;

namespace CMS_SC.WebUserControls
{
  public partial class mod_testata : System.Web.UI.UserControl
  {

    /// <summary>
    /// calcola currentPage
    /// </summary>
    protected string currPage
    {
      get
      {
        return Request.Url.LocalPath.Split('/').Last();
      }
    }
    /// <summary>
    /// definisce visibilità logo: sempre SE la pagina non è quella default (su cui il logo è visibile in grande...)
    /// </summary>
    public bool logoVisible
    {
      get
      {
        return currPage != "Default";
      }
    }
    /// <summary>
    /// titolo pagina
    /// </summary>
    public string titolo
    {
      get
      {
        return devicesAuthProxy.getPage(Request.Url).Replace(".aspx","");
      }
    }
    /// <summary>
    /// caricamento pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
      // altri controlli
      if (!Page.IsPostBack)
      {
        // sistemo lingua se selezionata...
        if (user_std.UtSn.lingua != "")
        {
          ddlLang.SelectedValue = user_std.UtSn.lingua;
        }
        // fix altro
        sRicerca.Visible = pageHasSearch;
        Page.Title = Request.Url.LocalPath.Replace("/","");
        // se ho cambiato pagina registro...)
        if (devicesAuthProxy.pagPrecedente != titolo)
        {
          devicesAuthProxy.pagPrecedente = devicesAuthProxy.pagCorrente;
        }
        // salvo pagina corrente
        devicesAuthProxy.pagCorrente = titolo;
        // fix logo
        imgLogo.Visible = logoVisible;
        // se la pagina NON è cambiata tengo ricerca
        if (devicesAuthProxy.pagCorrente == devicesAuthProxy.pagPrecedente)
        {
          searchVal = memLayer.ML.StringSessionObj("searchVal");
        }
        // altrimenti la svuoto...
        else
        {
          //PagCorrente(); // tolto 2015.02.24
          memLayer.ML.emptySessionVal("searchVal");
        }
        // se ho utente...
        if (devicesAuthProxy.stObj.isAuth)
        {
          // fix componenti
          lblUtente.DataBind();
        }
      }
      // SOLO se la pagina NON E' "safe"...
      if (memLayer.ML.confReadString("PageNoIndex").IndexOf(titolo) < 0)
      {
        bool userOk = checkUser();
        bool pageOk = checkPageIsAuth();
        // controllo se c'è utente in sessione..
        if ((userOk))
        {
          // ora controllo pagina...
          if (!pageOk)
          {
            if (devicesAuthProxy.stObj.isPageEnabled(devicesAuthProxy.pagPrecedente))
            {
              Response.Redirect(devicesAuthProxy.pagPrecedente);
            }
            else
            {
              Response.Redirect("Home");
            }
          }
        }
        else
        {
          // rimando pagina x registrazione devices SE NON E' già UserAdmin...
          if (memLayer.ML.CRS("PageNoIndex").IndexOf(titolo) < 0)
          {
            Response.Redirect("UserAdmin");
          }
        }
      }
    }
    /// <summary>
    /// verifica che la pagina sia tra quelle autorizzate x l'utente
    /// </summary>
    /// <returns></returns>
    private bool checkPageIsAuth()
    {
      bool allOk = false;
      bool pageSafe = (memLayer.ML.confReadString("PageNoIndex").IndexOf(titolo) >= 0);
      bool pageAuth = devicesAuthProxy.stObj.isPageEnabled(titolo);
      allOk = (pageSafe || pageAuth);
      return allOk;
    }
    /// <summary>
    /// verifica presenza utente autorizzato in sessione
    /// </summary>
    private bool checkUser()
    {
      bool allOk = devicesAuthProxy.stObj.isAuth;
      if (!allOk)
      {
        // controllo cookie device...
        allOk = checkAuthCookieCMS_SC();
        if (!allOk)
        {
          ResetUser();
        }
      }
      return allOk;
    }
    /// <summary>
    /// verifica la presenza di un cookie VALIDO per autorizzare il device ed avvia utente...
    /// </summary>
    private bool checkAuthCookieCMS_SC()
    {
      bool answ = false;
      try
      {
        HttpCookie cookie = Request.Cookies[devicesAuthProxy.AuthCookieName];
        if (!(cookie == null || cookie.Value == ""))
        {
          // ricavo utente da cookie...
          string userAgent = "";
          string postazione_IP = "";
          string devSecret = cookie.Value;
          DS_Auth.AnagDevicesRow device = null;
          // cerco il device...ogni dipendente può averne + di 1 registrato a suo nome...
          string email = "";
          try
          {
            device = devicesAuthProxy.stObj.taAnagDev.getByDeviceSecret(devSecret)[0];
            email = device.USER_NAME;
          }
          catch (Exception exc)
          {
            logger.lg.scriviLog(string.Format("{0}", exc), tipoLog.EXCEPTION);
          }
          // cerco se si tratti PER CASO di un cookie di auth "base" per utenti base...
          if (email == "")
          {
            try
            {
              email = devicesAuthProxy.decodeKey(cookie.Value);
              // cerco SE email sia valida...
              if (devicesAuthProxy.stObj.checkUserEmail(email))
              {
                // se l'utente è "base" procedo...
                if (devicesAuthProxy.stObj.numAuth(email) != 0)
                {
                  email = "";
                }
              }
              else
              {
                email = "";
              }
            }
            catch
            { }
          }

          if (email != "")
          {
            // aggiorno descrizione (user agent) ed IP...
            userAgent = Request.UserAgent;
            postazione_IP = Request.UserHostAddress;
            // controllo IP e DeviceDescription x eventuale update
            if (device != null)
            {
              if (((device.lastIPv4 != postazione_IP) || (device.Description != userAgent)))
              {
                try
                {
                  // salvo ultimo "contatto" del device aggiornando descrizione ed IP
                  devicesAuthProxy.stObj.taAnagDev.updateIP(device.IdxDevice, DateTime.Now, userAgent, postazione_IP);
                }
                catch
                { }
              }
            }
            // salvo in sessione utente l'email...
            memLayer.ML.setSessionVal("email", email);
            // avvio utente...
            devicesAuthProxy.stObj.startUpUtente(email);
            // salvo dati di AUTH OP (x visualizzazione in testata...)
            OpAuth.startOpAuth(email, devicesAuthProxy.stObj.CognomeNome);
            lblUtente.DataBind();
            // salvo gruppo...
            if (devicesAuthProxy.stObj.isAuth)
            {
              // se tutto ok
              memLayer.ML.setSessionVal("Gruppo", devicesAuthProxy.stObj.rigaUtente.CodGruppo);
              answ = true;
            }

          }
        }
      }
      catch (Exception exc)
      {
        logger.lg.scriviLog(string.Format("Errore in checkAuthCookie:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
      }
      return answ;
    }
    /// <summary>
    /// resetta utente
    /// </summary>
    private void ResetUser()
    {
      devicesAuthProxy.stObj.clearAllUserData();
      // svuoto cookie...
      memLayer.ML.setCookieVal(devicesAuthProxy.AuthCookieName, "");
      memLayer.ML.emptyCookieVal(devicesAuthProxy.AuthCookieName);
    }
    /// <summary>
    /// classe grafica da pagina corrente
    /// </summary>
    /// <param name="nomeElem"></param>
    /// <returns></returns>
    public string liClass(string nomeElem)
    {
      string answ = "";
      if (user_std.pagCorrente != "")
      {
        try
        {
          if (nomeElem.IndexOf(user_std.pagCorrente) >= 0) answ = "active table-primary";
        }
        catch
        { }
      }
      return answ;
    }
    /// <summary>
    /// tooltip che indica se user autorizzato 
    /// </summary>
    public string usrAuthToolTip
    {
      get
      {
        string answ = "";
        try
        {
          if (userAuthOk)
          {
            answ = string.Format("{0} - {1}", traduci("UserAuthOk"), OpAuth.currAuth.CognomeNome);
          }
          else
          {
            answ = traduci("UserAuthKo");
          }
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// text x user autorizzato 
    /// </summary>
    public string usrAuthText
    {
      get
      {
        string answ = "...";
        try
        {
          if (userAuthOk)
          {
            answ = OpAuth.currAuth.CognomeNome;
          }
          else
          {
            answ = "...";
          }
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// css x colore icona user auth
    /// </summary>
    public string usrAuthCss
    {
      get
      {
        string answ = "";
        try
        {
          if (userAuthOk)
          {
            answ = "checkOk";
          }
          else
          {
            answ = "checkKo";
          }
        }
        catch
        { }
        return answ;
      }
    }
    protected bool userAuthOk
    {
      get
      {
        return OpAuth.isAuth || devicesAuthProxy.stObj.isAuth;
      }
    }
    /// <summary>
    /// verifica visibilità in base al menù...
    /// </summary>
    /// <param name="nomeMenu"></param>
    /// <returns></returns>
    public string checkShow(string nomeMenu)
    {
      string answ = "hidden ";
      // verifico: se è userIsSuperAdmin vede tutto
      if (userIsSuperAdmin)
      {
        answ = "";
      }
      else if (userIsCapoOfficina)
      {
        // controllo in base a cosa richiesto...
        if (nomeMenu == "Settings")
        {
          answ = "hidden ";
        }
        else
        {
          answ = "";
        }
      }
      else if (userIsAnagAdmin)
      {
        // controllo in base a cosa richiesto...
        if ((nomeMenu == "Anagrafiche") || (nomeMenu == "Settings"))
        {
          answ = "hidden ";
        }
        else
        {
          answ = "";
        }
      }
      else
      {
        // controllo in base a cosa richiesto...
        if (nomeMenu == "Collaudi")
        {
          answ = "";
        }
        else
        {
          answ = "hidden ";
        }
      }
      return answ;
    }
    /// <summary>
    /// wrapper traduzione
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduci(object lemma)
    {
      return user_std.UtSn.Traduci(lemma.ToString());
    }
    /// <summary>
    /// verifica se utente sia SuperAdmin
    /// </summary>
    public bool userIsSuperAdmin
    {
      get
      {
        return devicesAuthProxy.stObj.userHasRight(memLayer.ML.CRS("SuperAdminRole"));
      }
    }
    /// <summary>
    /// verifica se utente sia SuperUser
    /// </summary>
    public bool userIsCapoOfficina
    {
      get
      {
        return devicesAuthProxy.stObj.userHasRight(memLayer.ML.CRS("CapoOfficinaRole"));
      }
    } /// <summary>
      /// verifica se utente sia SuperUser
      /// </summary>
    public bool userIsCapoGruppo
    {
      get
      {
        return devicesAuthProxy.stObj.userHasRight(memLayer.ML.CRS("CapoGruppo"));
      }
    }
    /// <summary>
    /// verifica se utente sia SuperUser
    /// </summary>
    public bool userIsAnagAdmin
    {
      get
      {
        return devicesAuthProxy.stObj.userHasRight(memLayer.ML.CRS("AnagAdminRole"));
      }
    }
    /// <summary>
    /// verifica se la pagina abbia abilitato il search
    /// </summary>
    public bool pageHasSearch { get; set; }
    /// <summary>
    /// modifica campo ricerca...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void txtSearch_TextChanged(object sender, EventArgs e)
    {
      // salvo in sessione
      memLayer.ML.setSessionVal("searchVal", txtSearch.Text.Trim());
    }
    /// <summary>
    /// valore ricerca
    /// </summary>
    public string searchVal
    {
      get
      {
        return txtSearch.Text.Trim();
      }
      set
      {
        txtSearch.Text = value;
        memLayer.ML.setSessionVal("searchVal", value);
      }
    }

    protected void lbReset_Click(object sender, EventArgs e)
    {
      searchVal = "";
    }

    protected void ddlLang_SelectedIndexChanged(object sender, EventArgs e)
    {
      // imposto lingua selezionata...
      user_std.UtSn.lingua = ddlLang.SelectedValue;
    }
  }
}