using framework_business;
using framework_library;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;


public partial class controls_module_surfaceSignature : System.Web.UI.UserControl, ISurfaceControlBase
{
    private enum FileExtension { pdf, doc, docx, xls, xlsx, txt, jpg, jpeg, png, gif, htm, html }

    #region override

    /// <summary>
    /// Reload Control 
    /// </summary>
    /// <param name="controlFieldData"></param>
    /// <param name="alternateView"></param>
    /// <param name="readOnly"></param>
    public void ReloadControl(oSurfaceFieldData controlFieldData, bool alternateView = false, bool readOnly = false)
    {
        try
        {
            try
            {
                //Setup validation group
                ISurfaceBase parent = (ISurfaceBase)this.NamingContainer;
                string parentName = parent.AppRelativeVirtualPath;
                int iLastIndex = parentName.LastIndexOf("/") + 1;
                string validate = parentName.Substring(iLastIndex).Replace("_form.ascx", "");
                btnAddSignature.ValidationGroup = validate;
            }
            catch
            { }


            _SurfaceSignature.itemId = controlFieldData.surfaceItemId;
            foreach (oSurfaceField field in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "recId", controlFieldData.surfaceFieldID.ToString()))
            {
                _SurfaceSignature.fieldId = field.recId;
                break;
            }

            if (_SurfaceSignature.itemId > 0)
            {
                foreach (oSurfaceSignature sig in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceSignature), "fieldId,itemId", _SurfaceSignature.fieldId + "," + _SurfaceSignature.itemId))
                {
                    _SurfaceSignature = sig;
                    break;
                }

            }

            PopulateSignatureControl();
            //PreventOverwriteProvider.EnableImageProvider(this, imgEdSignature);

        }
        catch (Exception ex)
        {
            exception.HandleException("fileUploader:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Control Data
    /// </summary>
    /// <param name="_surfaceFieldData"></param>
    public void SaveControlData(ref oSurfaceFieldData _surfaceFieldData)
    {

        try
        {
            SaveSignatureControlValues();
            if (_SurfaceSignature.recId > 0)
            {
                if (xData.UpdateTyped("recId", _SurfaceSignature.recId.ToString(), typeof(oSurfaceSignature), _SurfaceSignature))
                {

                }
            }
            else
            {
                _SurfaceSignature.recId = xData.SaveTyped("recId", typeof(oSurfaceSignature), _SurfaceSignature);
                if (_SurfaceSignature.recId > 0)
                {

                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("surface:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion

    #region Methods

    /// <summary>
    /// Populate Signature Control
    /// </summary>
    private void PopulateSignatureControl()
    {
        try
        {
            //fetch configurtaion
            oSurfaceSignatureConfig _config = new oSurfaceSignatureConfig();

            foreach (oSurfaceSignatureConfig conf in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceSignatureConfig), "fieldId", _SurfaceSignature.fieldId.ToString()))
            {
                _config = conf;
                break;
            }

            //signature image handling
            if (_SurfaceSignature.signatureFile != String.Empty)
            {
                imgSignature.ImageUrl = "~/upload/" + _SurfaceSignature.signatureFile;
                lblSignatureDate.Text = _SurfaceSignature.signatureDate.ToString("dd-MM-yyyy HH:mm");
                grpDateSigned.Visible = true;
                if (_config.allowSignatureEdit)
                {
                    btnAddSignature.Visible = true;
                    btnAddSignature.Text = "Redo Signature";
                }
                else
                { btnAddSignature.Visible = false; }
            }
            else
            {
                btnAddSignature.Visible = true;
                grpDateSigned.Visible = false;
            }

            //signature photo
            pnlImagePhoto.Visible = _config.includePhoto;
            if (_SurfaceSignature.photoFile != String.Empty)
            {
                
                imgSignaturePhoto.ImageUrl = "~/upload/" + _SurfaceSignature.photoFile;
                imgSignaturePhoto.CssClass = "img-responsive img-circle";
                lblPhotoDate.Text = _SurfaceSignature.photoDate.ToString("dd-MM-yyyy HH:mm");
                grpDatePhotoTaken.Visible = true;
                if (_config.allowPhotoEdit)
                { fuSignaturePicture.Visible = true; lnkSavePhoto.Visible = true; }
                else
                { fuSignaturePicture.Visible = false; lnkSavePhoto.Visible = false; }
            }
            else
            {
                fuSignaturePicture.Visible = true;
                lnkSavePhoto.Visible = true;
                grpDatePhotoTaken.Visible = false;
            }

            lblSignatureText.Text = _config.labelText;
            lblDisclaimer.Text = _config.disclaimer;

            txtSignatureAuthoritive.Text = _SurfaceSignature.authoritive;



        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Signature Values
    /// </summary>
    private void SaveSignatureControlValues()
    {
        try
        {
            _SurfaceSignature.authoritive = txtSignatureAuthoritive.Text;
            _SurfaceSignature.isActive = true;
        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion

    #region events



    /// <summary>
    /// Page Load Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {

    }


    /// <summary>
    /// Add Signature Button
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnAddSignature_Click(object sender, EventArgs e)
    {
        try
        {
            ISurfaceBase parent = (ISurfaceBase)this.NamingContainer;
            if (_SurfaceSignature.itemId == 0)
            {
                // If this is a new property, we need to save the gallery top down (Parent => Gallery)                
                parent.SaveControl(false, false, false);
            }
            string scriptVar = "$('#" + pnlSignatureModal.ClientID + "').closest('div').find('.modSignatureModal').modal(); SetupJSignature('" + palSig.ClientID + "')";
            ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "mySurfaceFileUploaderModal", scriptVar, true);

        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// File Uploaded event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void fuSignaturePicture_FileUploaded(object sender, Telerik.Web.UI.FileUploadedEventArgs e)
    {
        try
        {
            ISurfaceBase parent = (ISurfaceBase)this.NamingContainer;
            if (_SurfaceSignature.itemId == 0)
            {
                // If this is a new property, we need to save the gallery top down (Parent => Gallery)                
                parent.SaveControl(false, false, false);
            }

            string signaturePhotoFolder = "surface/";
            signaturePhotoFolder += _SurfaceSignature.itemId;
            string randomFileName = utils.RandomString(5, true) + "_" + e.File.FileName.Substring(e.File.FileName.LastIndexOf(".")) + "_" + DateTime.Now.ToString("yyyy-MM-dd-HH-mm");
            string filePath = Server.MapPath("~/upload/" + signaturePhotoFolder + "/signature/photo/");
            utils.validateFolder(filePath);

            //save to file system with new image name
            e.File.SaveAs(filePath + randomFileName + e.File.GetExtension());

            _SurfaceSignature.photoFile = signaturePhotoFolder + "/signature/photo/" + randomFileName + e.File.GetExtension();
            _SurfaceSignature.photoDate = DateTime.Now;

        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Photo
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkSavePhoto_Click(object sender, EventArgs e)
    {
        try
        {
            if (_SurfaceSignature.photoFile != String.Empty)
            {
                SaveSignatureControlValues();

                if (_SurfaceSignature.recId > 0)
                {
                    if (xData.UpdateTyped("recId", _SurfaceSignature.recId.ToString(), typeof(oSurfaceSignature), _SurfaceSignature))
                    {
                        PopulateSignatureControl();
                    }
                }
                else
                {
                    _SurfaceSignature.recId = xData.SaveTyped("recId", typeof(oSurfaceSignature), _SurfaceSignature);
                    if (_SurfaceSignature.recId > 0)
                    {
                        PopulateSignatureControl();
                    }
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save the Drawn Signature
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnklSaveSignature_Click(object sender, EventArgs e)
    {
        try
        {
            string signatureFolder = "surface/";
            signatureFolder += _SurfaceSignature.itemId;
            string randomFileName = utils.RandomString(9, true) + "_" + DateTime.Now.ToString("yyyy-MM-dd-HH-mm") + ".png";
            string filePath = Server.MapPath("~/upload/" + signatureFolder + "/signature/");
            utils.validateFolder(filePath);
            //save
            SaveSignatureControlValues();

            //get base 64 string
            string imgData = hfSigImgValue.Value;
            //convert to byte array
            byte[] bytes = Convert.FromBase64String(imgData.Replace("data:image/png;base64,", ""));

            System.Drawing.Image image;
            using (MemoryStream ms = new MemoryStream(bytes))
            {
                image = System.Drawing.Image.FromStream(ms);
            }
            image.Save(filePath + randomFileName, System.Drawing.Imaging.ImageFormat.Png);
            image.Dispose();

            _SurfaceSignature.signatureFile = signatureFolder + "/signature/" + randomFileName;
            _SurfaceSignature.signatureDate = DateTime.Now;

            if (_SurfaceSignature.recId > 0)
            {
                if (xData.UpdateTyped("recId", _SurfaceSignature.recId.ToString(), typeof(oSurfaceSignature), _SurfaceSignature))
                {
                    PopulateSignatureControl();
                    ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "mySurfaceSignatureModalClose", "TaskFileUploadCancel(); $('#" + pnlSignatureModal.ClientID + "').closest('div').find('.modSignatureModal').modal('hide');$('body').removeClass('modal-open');", true);
                }
            }
            else
            {
                _SurfaceSignature.recId = xData.SaveTyped("recId", typeof(oSurfaceSignature), _SurfaceSignature);
                if (_SurfaceSignature.recId > 0)
                {
                    PopulateSignatureControl();

                    ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "mySurfaceSignatureModalClose", "TaskFileUploadCancel(); $('#" + pnlSignatureModal.ClientID + "').closest('div').find('.modSignatureModal').modal('hide');$('body').removeClass('modal-open');", true);
                }
            }

        }
        catch (Exception ex)
        {
            exception.HandleException("surfaceSignature:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }



    #endregion

    #region Properties


    private oSurfaceSignature _SurfaceSignature
    {
        get
        {
            if (ViewState["surfaceSignature"] != null)
            {
                return (oSurfaceSignature)ViewState["surfaceSignature"];
            }
            else
            {
                ViewState["surfaceSignature"] = new oSurfaceSignature();
                return (oSurfaceSignature)ViewState["surfaceSignature"];
            }
        }
        set
        {
            ViewState["surfaceSignature"] = value;
        }
    }

    #endregion





}