using System;
using System.Linq;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;

using CMS.Ecommerce;
using CMS.EcommerceProvider;
using CMS.SiteProvider;
using CMS.GlobalHelper;
using CMS.CMSHelper;
using CMS.WebAnalytics;
using CMS.SettingsProvider;
using CMS.PortalControls;
using System.Collections.Generic;
using CMS.DocumentEngine;
using CMS.Helpers;
using CMS.Globalization;
using Pux.Utils;
using CMS.DataEngine;

public partial class CMSWebParts_Pux_Ecommerce_ShoppingCartSummary : CMSAbstractWebPart
{

    #region "Public settings"

    public string ShippingPrefix
    {
        get
        {
            return ValidationHelper.GetString(GetValue("ShippingPrefix"), "shipping");
        }
        set
        {
            SetValue("ShippingPrefix", value);
        }
    }

    public int CategoryLevel
    {
        get
        {
            return ValidationHelper.GetInteger(GetValue("CategoryLevel"), 1);
        }
        set
        {
            SetValue("CategoryLevel", value);
        }
    }

    public string TransactionAffiliation
    {
        get
        {
            return ValidationHelper.GetString(GetValue("TransactionAffiliation"), "puxtravel.cz");
        }
        set
        {
            SetValue("TransactionAffiliation", value);
        }
    }

    public string TransactionEvent
    {
        get
        {
            return ValidationHelper.GetString(GetValue("TransactionEvent"), "Odesl�n� objedn�vky");
        }
        set
        {
            SetValue("TransactionEvent", value);
        }
    }

   


    #endregion

    #region "Properties"

    /// <summary>
    /// OrderId from session. If orderid is not set in session it getter returns 0.
    /// </summary>
    public int OrderId
    {
        get
        {
            int urlId = ValidationHelper.GetInteger(URLHelper.GetUrlParameter(RequestContext.CurrentURL, "manualorder"), 0);
            if (urlId > 0)
                return urlId;

            int sessionId = ValidationHelper.GetInteger(SessionHelper.GetValue("orderid"), 0);
            if (sessionId > 0)
                return sessionId;

            string orderHash = QueryHelper.GetString("o", string.Empty);
            return ValidationHelper.GetInteger(WindowHelper.GetItem(orderHash), 0);
        }
    }

    private List<OrderItemInfo> orderedItems;
    public List<OrderItemInfo> OrderedItems
    {
        get
        {
            if ( orderedItems == null )
            {
                var items = new List<OrderItemInfo>();
                foreach ( var item in OrderItemInfoProvider.GetOrderItems(OrderId) )
                {
                    items.Add(item);
                }

                orderedItems = items.OrderBy(p => p.OrderItemID).ToList();
            }

            return orderedItems;
        }
    }

    private OrderInfo orderInfo;
    public OrderInfo OrderInfo
    {
        get
        {
            if (orderInfo == null) orderInfo = OrderInfoProvider.GetOrderInfo(OrderId);
            return orderInfo;
        }
    }

    private CurrencyInfo currency;
    public CurrencyInfo Currency
    {
        get
        {
            if (currency == null) currency = CurrencyInfoProvider.GetCurrencyInfo(OrderInfo.OrderCurrencyID);
            return currency;
        }
    }

    private PaymentOptionInfo payment;
    public PaymentOptionInfo Payment
    {
        get
        {
            if (payment == null) payment = PaymentOptionInfoProvider.GetPaymentOptionInfo(OrderInfo.OrderPaymentOptionID);
            return payment;
        }
    }

    private ShippingOptionInfo shippingOption;
    public ShippingOptionInfo ShippingOption
    {
        get
        {
            if (shippingOption == null) shippingOption = ShippingOptionInfoProvider.GetShippingOptionInfo(OrderInfo.OrderShippingOptionID);
            return shippingOption;
        }
    }

    private bool mShowProductOptionsDetails = false;

    #endregion

    #region "Page lifecycle"

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

    protected void Page_Load(object sender, EventArgs e)
    {
        if ( OrderInfo == null )
        {
            Visible = false;
            StopProcessing = false;

            return;
        }

        // Show addresses
        AddressInit();

        PaymentAndShippingInit();

        GoogleAnalyticsLiteral.Text = GenerateGoogleAnalyticsDataLayerScript();

        if (SettingsKeyInfoProvider.GetBoolValue("HeurekaSendRequestInShoppingSummary", SiteContext.CurrentSiteID))
        {
            string heurekaRequestUrl, heurekaReuqestStatusCode;
            Pux.Heureka.HeurekaOrderHelper.ExportOrder(OrderInfo, out heurekaRequestUrl, out heurekaReuqestStatusCode);
            OrderInfo.OrderCustomData["heurekaRequestUrl"] = heurekaRequestUrl;
            OrderInfo.OrderCustomData["heurekaReuqestStatusCode"] = heurekaReuqestStatusCode;
            OrderInfo.Update();
        }
        if (!IsPostBack)
        {
            DataBind();
        }
    }
    

    #endregion

    private void PaymentAndShippingInit()
    {
        // shipping option and payment method
        lblShippingOption.Text = GetString("Ecommerce.CartContent.ShippingOption");
        lblPaymentMethod.Text = GetString("Ecommerce.CartContent.PaymentMethod");
        lblShipping.Text = GetString("Ecommerce.CartContent.Shipping");

        // shipping info
        if (ShippingOption != null)
        {
            plcShipping.Visible = true;
            plcShippingOption.Visible = true;
            lblShippingOptionValue.Text = HTMLHelper.HTMLEncode(ShippingOption.ShippingOptionDisplayName);
            lblShippingValue.Text = CurrencyInfoProvider.GetFormattedPrice(OrderInfo.OrderTotalShipping, Currency);
            if ( OrderInfo.OrderTotalShipping == 0 )
            {
                lblShippingValue.Text = GetString("pux.Ecommerce.Cart.FreeShipping");
            }
        }
        else
        {
            plcShippingOption.Visible = false;
            plcShipping.Visible = false;
        }

        if ( OrderInfo.OrderDiscountCouponID > 0 )
        {
            double discount = ValidationHelper.GetDouble(OrderInfo.OrderCustomData["DiscountValue"], 0);
            if ( discount > 0 )
            {
                plcAppliedDiscountCouponValue.Visible = true;
                lblAppliedDiscountCouponValue.Text = CurrencyInfoProvider.GetFormattedPrice(discount, Currency);
            }
        }

        // payment info
        if (Payment != null)
        {
            lblPaymentMethodValue.Text = HTMLHelper.HTMLEncode(Payment.PaymentOptionDisplayName);
        }

        //// total price initialization
        lblTotalPrice.Text = GetString("ecommerce.cartcontent.totalprice");
        lblTotalPriceValue.Text = CurrencyInfoProvider.GetFormattedPrice(OrderInfo.OrderTotalPriceInMainCurrency, Currency);
    }

    private void AddressInit()
    {
        // addresses initialization
        pnlBillingAddress.GroupingText = GetString("Ecommerce.CartPreview.BillingAddressPanel");
        pnlShippingAddress.GroupingText = GetString("Ecommerce.CartPreview.ShippingAddressPanel");
        pnlCompanyAddress.GroupingText = GetString("Ecommerce.CartPreview.CompanyAddressPanel");

        FillBillingAddressForm(OrderInfo.OrderBillingAddress);
        FillShippingAddressForm(OrderInfo.OrderShippingAddress);

        if (OrderInfo.OrderCompanyAddress != null)
        {
            lblCompany.Text = GetAddressText(OrderInfo.OrderCompanyAddress);
            pnlCompanyAddress.Visible = true;
        }
        else
        {
            pnlCompanyAddress.Visible = false;
        }
    }

    /// <summary>
    /// Fills billing address form.
    /// </summary>
    /// <param name="addressId">Billing address id</param>
    protected void FillBillingAddressForm(IAddress address)
    {
        this.lblBill.Text = GetAddressText(address);
    }

    /// <summary>
    /// Fills shipping address form.
    /// </summary>
    /// <param name="addressId">Shipping address id</param>
    protected void FillShippingAddressForm(IAddress address)
    {
        this.lblShip.Text = GetAddressText(address);
    }

    /// <summary>
    /// Displays product error message in shopping cart content table.
    /// </summary>
    /// <param name="skuErrorMessage">Error message to be displayed</param>
    protected string DisplaySKUErrorMessage(object skuErrorMessage)
    {
        string err = ValidationHelper.GetString(skuErrorMessage, "");
        if (err != "")
        {
            return "<br /><span class=\"ItemsNotAvailable\">" + err + "</span>";
        }
        return "";
    }

    /// <summary>
    /// Returns formated value string.
    /// </summary>
    /// <param name="value">Value to format</param>
    protected string GetFormattedValue(object value)
    {
        double price = ValidationHelper.GetDouble(value, 0);
        return CurrencyInfoProvider.GetFormattedValue(price, Currency);
    }

    /// <summary>
    /// Returns formatted and localized SKU name.
    /// </summary>
    /// <param name="value">SKU name</param>
    /// <param name="isProductOption">Indicates if cart item is product option</param>
    /// <param name="isBundleItem">Indicates if cart item is bundle item</param>
    protected string GetSKUName(object value)
    {
        if ( value is SKUInfo )
        {
            SKUInfo info = value as SKUInfo;

            return info.IsProductOption ? string.Format("<span style=\"font-size:90%\"> - {0}</span>", info.SKUName) : info.SKUName;
        }

        return value.ToString();
    }

    protected bool IsProductOption(object value)
    {
        if ( value is SKUInfo )
        {
            SKUInfo info = value as SKUInfo;

            return info.IsProductOption;
        }

        return false;
    }

    protected string GetSKUName(object value, object isProductOption, object isBundleItem, object itemText)
    {
        string name = ResHelper.LocalizeString((string)value);
        string text = itemText as string;

        // If it is a product option or bundle item
        if (ValidationHelper.GetBoolean(isProductOption, false) || ValidationHelper.GetBoolean(isBundleItem, false))
        {
            StringBuilder skuName = new StringBuilder("<span style=\"font-size:90%\"> - ");
            skuName.Append(HTMLHelper.HTMLEncode(name));

            if (!string.IsNullOrEmpty(text))
            {
                skuName.Append(" '" + HTMLHelper.HTMLEncode(text) + "'");
            }

            skuName.Append("</span>");
            return skuName.ToString();
        }
        // If it is a parent product
        else
        {
            return HTMLHelper.HTMLEncode(name);
        }
    }

    public String GenerateGoogleAnalyticsDataLayerScript()
    {
        StringBuilder sb = new StringBuilder();

        sb.Append("<script>");
        sb.Append("dataLayer = window.dataLayer || [];");
        sb.Append(@"dataLayer.push({
                        'transactionId': '" + OrderInfo.OrderID + @"',
                        'transactionAffiliation': '" + TransactionAffiliation + @"',
                        'transactionCurrency': '" + Currency.CurrencyCode + @"',
                        'transactionTotal': '" + (OrderInfo.OrderTotalPriceInMainCurrency - OrderInfo.OrderTotalShipping) + @"',
                        'transactionShipping': '" + OrderInfo.OrderTotalShipping + @"',
                        'transactionCurrency': '" + Currency.CurrencyCode.ToUpperInvariant() + @"',
                        'transactionTax': '" + OrderInfo.OrderTotalTax.ToString().Replace(',', '.') + @"', " + Environment.NewLine +
                        GenerateGoogleAnalyticsTransactionProducts() + @",
                        'event':'" + TransactionEvent + @"'
                    });");

        sb.Append("</script>");

        return sb.ToString();
    }

    public String GenerateGoogleAnalyticsTransactionProducts()
    {
        StringBuilder sb = new StringBuilder();

        sb.Append("'transactionProducts': [");

        bool isFirst = true;
        foreach (var item in OrderedItems)
        {
            var price = Math.Round(item.OrderItemUnitPrice > 0 ? item.OrderItemUnitPrice : item.OrderItemTotalPriceInMainCurrency / item.OrderItemUnitCount);
            if (price == 0)
                continue;

            //if ( item.OrderItemSKU.IsProductOption )
                //continue;

            if ( isFirst )
            {
                isFirst = false;
            }
            else
            {
                sb.Append(",");
            }
            sb.Append(Environment.NewLine);
            sb.Append("{");
            sb.AppendFormat("name: '{0}', ", item.OrderItemSKUName.Trim());
            sb.AppendFormat("sku: '{0}', ", item.OrderItemSKUID);
            if (item.OrderItemSKU.IsProductOption)
            {
                sb.AppendFormat("category: '{0}', ", GetOrderItemProductOptionCategory(item.OrderItemSKUID));
            }
            else
            {
                sb.AppendFormat("category: '{0}', ", GetOrderItemCategory(item.OrderItemSKUID));
            }
            sb.AppendFormat("price: '{0}', ", price);
            sb.AppendFormat("quantity: {0}", item.OrderItemUnitCount);
            sb.Append("}");
        }

        // add shipping
        if ( ShippingOption != null )
        {
            sb.Append(",");
            sb.Append("{");
            sb.AppendFormat("name: '{0} {1}', ", ShippingPrefix, ResHelper.LocalizeString(ShippingOption.ShippingOptionDisplayName.Trim()));
            sb.AppendFormat("sku: 'ship-{0}', ", ShippingOption.ShippingOptionID);
            sb.AppendFormat("category: '{0}', ", ShippingPrefix);
            sb.AppendFormat("price: '{0}', ", OrderInfo.OrderTotalShipping);
            sb.Append("quantity: 1");
            sb.Append("}");
        }

        sb.Append("]");
        sb.Append(Environment.NewLine);

        return sb.ToString();
    }

    private string GetOrderItemProductOptionCategory(int skuId)
    {
        var skuInfo = SKUInfoProvider.GetSKUInfo(skuId);
        if (skuInfo != null)
        {
            var skus = SKUInfoProvider.GetSKUs().Where(string.Format("SKUID = (SELECT TOP 1 SKUID FROM COM_SKUOptionCategory WHERE CategoryID = {0})", skuInfo.SKUOptionCategoryID));
            if (skus != null && skus.Count > 0)
            {
                return GetOrderItemCategory(skus.First().SKUID);
            }
        }

        return string.Empty;
    }

    private string GetOrderItemCategory(int skuId)
    {
        var nodes = TreeHelper.SelectNodes("/%", false, TreeProvider.ALL_CLASSNAMES, string.Format("NodeSKUID = {0}", skuId));
        if ( nodes != null && nodes.Items != null && nodes.Items.Count > 0 )
        {
            TreeNode treeNode = nodes.Items[0];
            while ( treeNode != null && treeNode.NodeLevel > 0 && treeNode.NodeLevel > CategoryLevel )
            {
                treeNode = treeNode.Parent;
            }

            if ( treeNode != null )
                return treeNode.DocumentName;
        }

        return string.Empty;
    }

    private string GetAddressText(IAddress address)
    {
        var countryInfo = CountryInfoProvider.GetCountryInfo(address.AddressCountryID);
        var countryName = countryInfo == null ? string.Empty : ResHelper.LocalizeString(countryInfo.CountryDisplayName);

        return new string[] { address.AddressPersonalName, address.AddressLine1, address.AddressLine2, address.AddressCity, address.AddressZip, countryName }.Where(p => !string.IsNullOrEmpty(p)).Join(", ");
    }

    public override string GetString(string stringName, string culture = null)
    {
        if (culture == null)
        {
            return TextTools.GetSiteResourceString(stringName);
        }

        return base.GetString(stringName, culture);
    }
}