using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using CMS.FormControls;
using CMS.EventLog;
using CMS.GlobalHelper;
using CMS.DataEngine;
using System.Data;
using CMS.SettingsProvider;
using System.Text;
using CMS.Helpers;
using CMS.FormEngine;
using CMS.CustomTables;

public partial class ERPApps_ERPWebParts_ManyToManySelector : FormEngineUserControl
{
    #region "Properties"

    /// <summary>
    /// Local key name
    /// </summary>
    public string LocalKey
    {
        get
        {
            return ValidationHelper.GetString(GetValue("LocalKey"), String.Empty);
        }
        set
        {
            SetValue("LocalKey", value);
        }
    }

    /// <summary>
    /// Foreign key name
    /// </summary>
    public string ForeignKey
    {
        get
        {
            return ValidationHelper.GetString(GetValue("ForeignKey"), String.Empty);
        }
        set
        {
            SetValue("ForeignKey", value);
        }
    }

    /// <summary>
    /// Custom query code name for retreiving foreign data
    /// </summary>
    public string ForeignDataQuery
    {
        get
        {
            return ValidationHelper.GetString(GetValue("ForeignDataQuery"), String.Empty);
        }
        set
        {
            SetValue("ForeignDataQuery", value);
        }
    }

    /// <summary>
    /// Custom table name used as a relationship table
    /// </summary>
    public string CustomTableName
    {
        get
        {
            return ValidationHelper.GetString(GetValue("CustomTableName"), String.Empty);
        }
        set
        {
            SetValue("CustomTableName", value);
        }
    }

    /// <summary>
    /// Repeat layout for rendering checkboxlist
    /// </summary>
    public string RepeatLayout
    {
        get
        {
            return ValidationHelper.GetString(GetValue("RepeatLayout"), "flow");
        }
        set
        {
            SetValue("RepeatLayout", value);
        }
    }

    /// <summary>
    /// Number of columns. Makes sense only in table layout.
    /// </summary>
    public int RepeatColumns
    {
        get
        {
            return ValidationHelper.GetInteger(GetValue("RepeatColumns"), 1);
        }
        set
        {
            SetValue("RepeatColumns", value);
        }
    }
    

    /// <summary>
    /// Gets or sets the value entered into the field, a hexadecimal color code in this case.
    /// </summary>

    public override Object Value
    {
        get
        {
            StringBuilder text = new StringBuilder();
            foreach ( ListItem item in list.Items )
            {
                if ( item.Selected )
                {
                    text.Append(item.Value + "|");
                }
            }

            if ( text.Length == 0 )
            {
                // no option selected
                return null;
            }

            return "|" + text.ToString();
        }
        set
        {
            EnsureItems();
            int[] existingRelations = GetExistingRelations(GetLocalKeyValue());
            foreach (var item in existingRelations)
            {
                var itemToSelect = list.Items.FindByValue(item.ToString());
                if (itemToSelect != null)
                {
                    itemToSelect.Selected = true;
                }
            }
        }
    }

    #endregion

   

    #region "Data handling"

    private int[] GetExistingRelations(int localKeyValue)
    {

        if ( localKeyValue == 0 )
        {
            return new int[0];
        }

        // select
       var values=  CustomTableItemProvider.GetItems(CustomTableName).WhereEquals(LocalKey, localKeyValue).Column(ForeignKey)
            .Select(x=>x.GetIntegerValue(ForeignKey, 0)).Distinct().ToArray();
        return values;
    }

    private void CreateNewRelations(int localKeyValue, GeneralConnection cn, LinkedList<int> values)
    {
        foreach ( var item in values )
        {
            var tableitem = new CustomTableItem(CustomTableName);
            tableitem.SetValue(LocalKey, localKeyValue);
            tableitem.SetValue(ForeignKey, item);
            tableitem.SetValue("ItemGUID", Guid.NewGuid());
            tableitem.Insert();
        }
    }

    private void DeleteOldRelations(int localKeyValue, GeneralConnection cn, LinkedList<int> values)
    {
        if ( values.Count == 0 )
        {
            var deleteWhere = new WhereCondition().WhereEquals(LocalKey, localKeyValue).ToString(true);
                CustomTableItemProvider.DeleteItems(CustomTableName, deleteWhere);
        }
        else
        {
            var deleteWhere = new WhereCondition().WhereEquals(LocalKey, localKeyValue)
                .WhereNotIn(ForeignKey,values.ToArray()).ToString(true);
            CustomTableItemProvider.DeleteItems(CustomTableName, deleteWhere);
        }
    }

    private int GetLocalKeyValue()
    {
        return ValidationHelper.GetInteger(Form.Data[LocalKey], 0);
    }

    #endregion

    #region "Events and actions"
    protected void Page_Load(object sender, EventArgs e)
    {
        if ( DataHelper.IsEmpty(CustomTableName) )
        {
            throw new Exception("ManyToMany: CustomTableName is not set.");
        }
        // set layout
        switch (RepeatLayout)
        {
            case "table":
                list.RepeatLayout = System.Web.UI.WebControls.RepeatLayout.Table;
                list.RepeatColumns = RepeatColumns;
                break;

            case "ul":
                list.RepeatLayout = System.Web.UI.WebControls.RepeatLayout.UnorderedList;
                break;

            default:
                list.RepeatLayout = System.Web.UI.WebControls.RepeatLayout.Flow;
                break;
        }
        EnsureItems();

        

        

        // set onAfterSave event handler
        Form.OnAfterSave += new EventHandler(Form_OnAfterSave);
    }

    private void EnsureItems()
    {
        if (list.Items.Count == 0)
        {
            // load items from database based on custom query
            SpecialFieldsDefinition specialFieldsDefinition = new SpecialFieldsDefinition(null, FieldInfo)
            {
                AllowDuplicates = false
            };
            SpecialFieldsDefinition specialFieldsDefinition1 = specialFieldsDefinition;
            if (!string.IsNullOrEmpty(ForeignDataQuery))
            {
                specialFieldsDefinition1.LoadFromQuery(ForeignDataQuery, QueryTypeEnum.SQLQuery, null, null);
            }
            specialFieldsDefinition1.FillItems(list.Items);
        }
    }

    public void Form_OnAfterSave(object sender, EventArgs e)
    {

        int localKeyValue = GetLocalKeyValue();

        if ( DataHelper.IsEmpty(localKeyValue) || localKeyValue <= 0 )
        {
            throw new Exception("Local key " + LocalKey + " does not exist in the form or is empty. Foreign keys not updated.");
        }

        GeneralConnection cn = ConnectionHelper.GetConnection();

        // data to be processed
        LinkedList<int> values = new LinkedList<int>();

        // use all checked checkboxes
        foreach ( ListItem item in list.Items )
        {
            if ( item.Selected )
            {
                values.AddLast(ValidationHelper.GetInteger(item.Value, 0));
            }
        }

        try
        {
            // delete old relations
            DeleteOldRelations(localKeyValue, cn, values);

            if ( values.Count > 0 )
            {
                // existing items in the database remove from collection for update
                // (i.e. existing items will not be updated)
                foreach ( var item in GetExistingRelations( localKeyValue) )
                {
                    LinkedListNode<int> delete = values.Find(item);
                    if ( delete != null )
                    {
                        values.Remove(delete);
                    }
                }

                // remaining values in "values" list should be inserted
                CreateNewRelations(localKeyValue, cn, values);
            }

        }
        catch ( Exception ex )
        {
            // log
            EventLogProvider.LogEvent(new EventLogInfo() { EventCode = "DB exception", EventType = "E", Source = "ManyToMany control", EventDescription = ex.Message + ex.StackTrace });
        }
    }


    #endregion
}