using System;
using System.Collections;
using System.Linq;
using System.Web.UI;
using System.Web.UI.WebControls;

using CMS.DataCom;
using CMS.EventLog;
using CMS.ExtendedControls.ActionsConfig;
using CMS.GlobalHelper;
using CMS.OnlineMarketing;
using CMS.SettingsProvider;
using CMS.UIControls;
using CMS.CMSHelper;
using System.Net;
using System.Web;

/// <summary>
/// Provides UI elements to display and edit CMS contact and possibly update it from the specified Data.com contact.
/// </summary>
[EditedObject(OnlineMarketingObjectType.CONTACT, "contactId")]
public partial class CMSModules_ContactManagement_Pages_Tools_Contact_Tab_DataCom : CMSDataComPage, ICallbackEventHandler
{
    #region "Variables"

    /// <summary>
    /// New instance of credential provider.
    /// </summary>
    private readonly ICredentialProvider credentialProvider = new UserCredentialProvider(CMSContext.CurrentUser);

    #endregion


    #region "Properties"

    /// <summary>
    /// Gets or sets the Data.com contact to display side-by-side with the CMS contact.
    /// </summary>
    public Contact Contact
    {
        get
        {
            return ViewState["DataComContact"] as Contact;
        }
        set
        {
            ViewState["DataComContact"] = value;
        }
    }


    /// <summary>
    /// Gets or sets the suggested Data.com contact filter when the Data.com search didn't return an exact match.
    /// </summary>
    public ContactFilter Filter
    {
        get;
        set;
    }


    /// <summary>
    /// Gets the site identifier of the edited contact.
    /// </summary>
    public int ContactSiteID
    {
        get
        {
            return ContactHelper.ObjectSiteID(EditedObject);
        }
    }


    /// <summary>
    /// Gets the unique identifier to pass the parameters on to the Data.com contact selection dialog window.
    /// </summary>
    private string ParametersIdentifier
    {
        get
        {
            string identifier = ViewState["PID"] as string;
            if (identifier == null)
            {
                identifier = Guid.NewGuid().ToString("N");
                ViewState["PID"] = identifier;
            }

            return identifier;
        }
    }


    /// <summary>
    /// Gets the unique identifier to pass the parameters on to the Data.com Buy contact dialog window.
    /// </summary>
    private string BuyParametersIdentifier
    {
        get
        {
            string identifier = ViewState["BuyPID"] as string;
            if (identifier == null)
            {
                identifier = Guid.NewGuid().ToString("N");
                ViewState["BuyPID"] = identifier;
            }

            return identifier;
        }
    }


    /// <summary>
    /// Returns redirect url to login page.
    /// </summary>
    private string LoginPageUrl
    {
        get
        {
            var url = "~/CMSModules/ContactManagement/Pages/Tools/DataCom/Login.aspx";
            url = URLHelper.AddParameterToUrl(url, "returnurl", HttpUtility.UrlEncode(URLHelper.CurrentURL));
            return url;
        }
    }

    #endregion


    #region "Life cycle methods"

    protected override void OnInit(EventArgs e)
    {
        base.OnInit(e);

        ContactInfo contact = EditedObject as ContactInfo;
        AuthorizeReadRequest(contact);

        ScriptHelper.RegisterDialogScript(Page);
    }


    protected void Page_Load(object sender, EventArgs e)
    {
        // Do not check login if it's a CallBack - search button was pressed (see CreateSearchActionClientScript method)
        if (!RequestHelper.IsCallback())
        {
            bool validCredential = false;
            try
            {
                validCredential = CheckCredential();
            }
            catch (Exception ex)
            {
                HandleException(ex);
                return;
            }

            if (!validCredential)
            {
                URLHelper.Redirect(LoginPageUrl);
            }
        }

        try
        {
            if (!String.IsNullOrEmpty(ContactHiddenField.Value))
            {
                JsonSerializer serializer = new JsonSerializer();
                Contact freshContact = serializer.Unserialize<Contact>(ContactHiddenField.Value);
                if (Contact == null)
                {
                    ContactForm.MergeHint = true;
                }
                else
                {
                    if (Contact.ContactId != freshContact.ContactId)
                    {
                        ContactForm.MergeHint = true;
                    }
                    else if (String.IsNullOrEmpty(Contact.Phone) && String.IsNullOrEmpty(Contact.Email) && (!String.IsNullOrEmpty(freshContact.Phone) || !String.IsNullOrEmpty(freshContact.Email)))
                    {
                        ContactForm.MergeHint = true;
                        ContactForm.MergeHintAttributes = new string[] { "Phone", "Email" };
                    }
                }
                Contact = freshContact;
            }
            ContactInfo contactInfo = EditedObject as ContactInfo;
            ContactIdentity identity = DataComHelper.CreateContactIdentity(contactInfo);
            Filter = identity.CreateFilter();
            // Do not search for contact if it's a CallBack - search button was pressed (see CreateSearchActionClientScript method)
            if (Contact == null && !RequestHelper.IsCallback())
            {
                DataComClient client = DataComHelper.CreateClient();
                IContactProvider provider = DataComHelper.CreateContactProvider(client, credentialProvider.GetCredential());
                ContactFinder finder = DataComHelper.CreateContactFinder(provider);
                Contact match = finder.Find(identity);
                if (match != null)
                {
                    ShowInformation(GetString("datacom.contactmatch"));
                    Contact = match;
                    ContactForm.MergeHint = true;
                }
                else
                {
                    ShowInformation(GetString("datacom.nocontactmatch"));
                }
            }
            InitializeHeaderActions();
            InitializeDataComForm();
        }
        catch (Exception exception)
        {
            HandleException(exception);
        }
    }

    
    protected override void OnPreRender(EventArgs e)
    {
        base.OnPreRender(e);
        if (Contact == null)
        {
            ContactFormPanel.CssClass = "Hidden";
            HeaderAction action = HeaderActions.ActionsList.SingleOrDefault(x => x.CommandName == "save");
            if (action != null)
            {
                action.Visible = false;
            }
        }
    }


    protected void HeaderActions_ActionPerformed(object sender, CommandEventArgs e)
    {
        switch (e.CommandName.ToLowerInvariant())
        {
            case "save":
                ContactInfo contact = EditedObject as ContactInfo;
                AuthorizeModifyRequest(contact);
                try
                {
                    if (ContactForm.Validate() && ContactForm.Store())
                    {
                        ContactForm.Merge();
                        BaseInfo data = ContactForm.Data as BaseInfo;
                        data.Generalized.SetObject();
                        Filter = null;
                        ShowChangesSaved();
                    }
                }
                catch (Exception exception)
                {
                    HandleException(exception);
                }
                break;

            case "logout":
                credentialProvider.SetCredential(new NetworkCredential());
                URLHelper.Redirect(LoginPageUrl);
                break;
        }
    }

    #endregion


    #region "Private methods"

    /// <summary>
    /// Initializes the form with the required dependencies and the specified CMS contact.
    /// </summary>
    protected void InitializeDataComForm()
    {
        IDataComConfiguration configuration = DataComHelper.GetConfiguration(ContactSiteID);
        ContactInfo contactInfo = EditedObject as ContactInfo;
        ContactForm.ParametersIdentifier = BuyParametersIdentifier;
        ContactForm.FormInformation = DataComHelper.GetContactFormInfo();
        ContactForm.EntityInfo = DataComHelper.GetContactEntityInfo();
        ContactForm.EntityMapping = configuration.GetContactMapping();
        ContactForm.EntityAttributeMapperFactory = DataComHelper.GetContactAttributeMapperFactory();
        ContactForm.Entity = Contact;
        ContactForm.EntityAttributeFormatter = DataComHelper.GetEntityAttributeFormatter();
        ContactForm.BuyContactEnabled = (credentialProvider.GetCredential() != null);
        ContactForm.DefaultFieldLayout = CMS.FormControls.FieldLayoutEnum.ThreeColumns;
        ContactForm.DefaultFormLayout = CMS.FormEngine.FormLayoutEnum.Standard;
        ContactForm.Restore(contactInfo);
    }


    /// <summary>
    /// Adds actions to the page header.
    /// </summary>
    protected void InitializeHeaderActions()
    {
        AddHeaderActions(new HeaderAction
        {
            ControlType = HeaderActionTypeEnum.LinkButton,
            Text = GetString("general.apply"),
            ImageUrl = GetImageUrl("CMSModules/CMS_Content/EditMenu/save.png"),
            CommandName = "save",
            RegisterShortcutScript = true
        });

        AddHeaderActions(new HeaderAction
        {
            ControlType = HeaderActionTypeEnum.LinkButton,
            Text = GetString("general.search"),
            ImageUrl = GetImageUrl("CMSModules/CMS_ContactManagement/search.png"),
            OnClientClick = CreateSearchActionClientScript()
        });

        AddHeaderActions(new HeaderAction
        {
            Text = string.Format(GetString("datacom.logout"), credentialProvider.GetCredential().UserName),
            GenerateSeparatorBeforeAction = true,
            ImageUrl = GetImageUrl("CMSModules/CMS_PortalEngine/OnSiteEdit/signout.png"),
            CommandName = "logout",
            OnClientClick = "return confirm('" + GetString("datacom.automation.confirmlogout") + "')"
        });

        HeaderActions.ActionPerformed += HeaderActions_ActionPerformed;
    }


    /// <summary>
    /// Creates a client script to open the dialog window to select a Data.com contact, and returns it.
    /// </summary>
    /// <returns>A client script to open the dialog window to select a Data.com contact.</returns>
    protected string CreateSearchActionClientScript()
    {
        string baseUrl = URLHelper.ResolveUrl("~/CMSModules/ContactManagement/Pages/Tools/DataCom/SelectContact.aspx?ContactID=" + ((ContactInfo)EditedObject).ContactID + "&SiteID=" + CMSContext.CurrentSiteID);
        string url = String.Format("{0}&pid={1}", baseUrl, ParametersIdentifier);
        string script = String.Format("function DataCom_SelectContact (arg, context) {{ modalDialog('{0}', 'SelectContact', '1000', '700', null); return false; }}", URLHelper.AddParameterToUrl(url, "hash", QueryHelper.GetHash(url)));
        ScriptHelper.RegisterClientScriptBlock(this, GetType(), "DataCom_SelectContact", script, true);

        return String.Format("{0}; return false;", Page.ClientScript.GetCallbackEventReference(this, null, "DataCom_SelectContact", null));
    }


    /// <summary>
    /// Displays an error message and logs the specified exception to the event log.
    /// </summary>
    /// <param name="exception">The exception to handle.</param>
    private void HandleException(Exception exception)
    {
        ErrorSummary.Report(exception);
        EventLogProvider.LogException("Data.com Connector", "ContactPage", exception);
    }


    /// <summary>
    /// Checks whether is user has provided credential to DataCom or not. If not, user is redirected to login page.
    /// </summary>
    /// <exception cref="Exception">Might be thrown when error occurs in communicating with Data.com</exception>
    private bool CheckCredential()
    {
        var credential = credentialProvider.GetCredential();
        var client = DataComHelper.CreateClient();
        return (credential != null && client.UserIsValid(credential));
    }

    #endregion


    #region ICallbackEventHandler Members

    string ICallbackEventHandler.GetCallbackResult()
    {
        return null;
    }


    void ICallbackEventHandler.RaiseCallbackEvent(string eventArgument)
    {
        JsonSerializer serializer = new JsonSerializer();
        Hashtable parameters = new Hashtable();
        if (Filter != null)
        {
            parameters["Filter"] = serializer.Serialize(Filter);
        }
        parameters["SiteID"] = ContactSiteID;
        WindowHelper.Add(ParametersIdentifier, parameters);
    }

    #endregion
}