using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;

using System.IO;
using System.ServiceModel;

namespace CSSI.Crm.Radman.Plugins
{
    public class RestrictDuplicatesPlugin : IPlugin
    {
        IOrganizationService service;
        string adminId = string.Empty;
        string OpenResourceId = string.Empty;
        string[] configvalues = null;
        string Logspath = string.Empty;
        bool isLogEnabled = false;

        public RestrictDuplicatesPlugin(string UnSecureConfig)
        {
            configvalues = UnSecureConfig.Split(',');
            adminId = configvalues[0];
            OpenResourceId = configvalues[1];
            Logspath = configvalues[2];
            if (configvalues.Length > 3)
                if (configvalues[3].ToLower() == "yes")
                    isLogEnabled = true;
            if (string.IsNullOrEmpty(Logspath))
                Logspath = @"D:\RADMan_Logs\RADMan_LogsDEV";

            CreateLog("Connection: " + UnSecureConfig);
        }

        public void Execute(IServiceProvider serviceProvider)
        {
            Microsoft.Xrm.Sdk.IPluginExecutionContext context = (Microsoft.Xrm.Sdk.IPluginExecutionContext)
            serviceProvider.GetService(typeof(Microsoft.Xrm.Sdk.IPluginExecutionContext));

            IOrganizationServiceFactory factory =
            (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
            service = factory.CreateOrganizationService(new Guid(adminId));

            if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
            {

                Entity entity = (Entity)context.InputParameters["Target"];
                 /*
                 * Restrict Duplicate Milestones and Components.
                 */
                 #region Milestone and Component Duplicate Check

                try
                {
                    Dictionary<string, Guid> dependents = new Dictionary<string, Guid>();
                    if (entity.Attributes.Contains("cssi_newprojectid"))
                    {
                        dependents.Add("cssi_newprojectid", ((EntityReference)entity.Attributes["cssi_newprojectid"]).Id);
                        CreateLog("Project Id: " + ((EntityReference)entity.Attributes["cssi_newprojectid"]).Id);

                    }

                    //cssi_memberid

                    //CreateLog("entity.LogicalName" + entity.LogicalName);

                    //foreach (KeyValuePair<string, object> attcoll in entity.Attributes)
                    //{
                    //    CreateLog("Attribute: " + attcoll.Key.ToString());
                    //}

                    //if (entity.Attributes.Contains("cssi_milestoneid"))
                    //{
                    //    CreateLog("entity.Attributes.Contains(cssi_milestoneid)");
                    //}

                    if (entity.Attributes.Contains("cssi_milestoneid") && entity.LogicalName != "cssi_milestone")
                    {
                        dependents.Add("cssi_milestoneid", ((EntityReference)entity.Attributes["cssi_milestoneid"]).Id);
                        CreateLog("Milestone ID: " + ((EntityReference)entity.Attributes["cssi_milestoneid"]).Id);
                    }

                    if (entity.LogicalName == "cssi_milestone")
                    {
                        //cssi_newprojectid
                        if (entity.Attributes.Contains("new_milestonecode"))
                        {
                            CreateLog("User entered Milestone Code:" + entity.Attributes["new_milestonecode"].ToString());

                            if (IsDuplicate(entity.LogicalName, "new_milestonecode", entity.Attributes["new_milestonecode"].ToString(), dependents))
                                throw new InvalidPluginExecutionException("Milestone with same code already exists in system. Pelase enter different Milestone code.");
                        }
                    }
                    else if (entity.LogicalName == "cssi_component")
                    {
                        //cssi_milestoneid
                        if (entity.Attributes.Contains("new_componentcode"))
                        {
                            CreateLog("User entered Component Code:" + entity.Attributes["new_componentcode"].ToString());

                            if (IsDuplicate(entity.LogicalName, "new_componentcode", entity.Attributes["new_componentcode"].ToString(), dependents))
                                throw new InvalidPluginExecutionException("Component with same code already exists in system. Pelase enter different Component code.");
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new InvalidPluginExecutionException(ex.Message.ToString());
                }

                #endregion

                 /*
                 * Restrict Duplicate Technical Panels.
                 */
                 #region Technical Panel Duplicate Check

                if (entity.LogicalName == "cssi_technicalinterviewpanel")
                {
                    CreateLog("create panel");
                    try
                    {
                        Dictionary<string, Guid> Panel = new Dictionary<string, Guid>();
                        if (entity.Attributes.Contains("cssi_technologies"))
                        {
                            CreateLog("create panel technologies" + ((EntityReference)entity.Attributes["cssi_technologies"]).Name);
                            CreateLog("create panel designation" + ((EntityReference)entity.Attributes["cssi_designation"]).Name);
                            Panel.Add("cssi_technologies", ((EntityReference)entity.Attributes["cssi_technologies"]).Id);
                            Panel.Add("cssi_designation", ((EntityReference)entity.Attributes["cssi_designation"]).Id);
                        }
                        else
                        {
                            CreateLog("create panel designation" + entity.Attributes["cssi_designation"].ToString());
                            Panel.Add("cssi_designation", ((EntityReference)entity.Attributes["cssi_designation"]).Id);
                        }

                        if (IsDuplicatePanel("cssi_technicalinterviewpanel", Panel))
                        {
                            throw new InvalidPluginExecutionException("Panel with same Technology and Designation already exists in system.");
                        }

                    }
                    catch (Exception e)
                    {
                        throw new InvalidPluginExecutionException(e.Message.ToString());
                    }
                }
                #endregion

                 /*
                 * Restrict Duplicate Project member roles.
                 */
                if (entity.LogicalName == "cssi_projectmemberroles")
                {
                    try
                    {
                        CreateLog("create Project member Role");

                        Dictionary<string, Guid> dependents = new Dictionary<string, Guid>();

                        if (entity.Attributes.Contains("cssi_projectid"))
                        {
                            dependents.Add("cssi_projectid", ((EntityReference)entity.Attributes["cssi_projectid"]).Id);
                            CreateLog("Project Id: " + ((EntityReference)entity.Attributes["cssi_projectid"]).Id);
                        }

                        if (entity.Attributes.Contains("cssi_roleid"))
                        {
                            dependents.Add("cssi_roleid", ((EntityReference)entity.Attributes["cssi_roleid"]).Id);
                            CreateLog("Role Id: " + ((EntityReference)entity.Attributes["cssi_roleid"]).Id);
                        }

                        Dictionary<string, Guid> Projectmemberrole = new Dictionary<string, Guid>();

                        if (entity.Attributes.Contains("cssi_memberid"))
                        {

                            Projectmemberrole.Add("cssi_memberid", ((EntityReference)entity.Attributes["cssi_memberid"]).Id);
                        }
                        if(OpenResourceId.ToString().ToUpper() != ((EntityReference)entity.Attributes["cssi_memberid"]).Id.ToString().ToUpper())
                            if (IsDuplicate(entity.LogicalName, "cssi_memberid", ((EntityReference)entity.Attributes["cssi_memberid"]).Id.ToString(), dependents))
                                throw new InvalidPluginExecutionException("Project member with same role already exists in this Project. Please provide appropriate role.");

                    }
                    catch (Exception e)
                    {
                        throw new InvalidPluginExecutionException(e.Message.ToString());
                    }
                }



            }
        }

        bool IsDuplicatePanel(string entityname, Dictionary<string, Guid> Pnl)
        {

            FilterExpression flex = new FilterExpression();

            if (Pnl.ContainsKey("cssi_technologies"))
            {
                CreateLog("contains technologies");
                flex = new FilterExpression()
                {
                    Conditions = 
                    { 
                        new ConditionExpression("cssi_technologies",ConditionOperator.Equal,Pnl["cssi_technologies"]),
                        new ConditionExpression("cssi_designation",ConditionOperator.Equal,Pnl["cssi_designation"])
                    }

                };
            }
            else
            {
                CreateLog("no technology");
                CreateLog(Pnl["cssi_designation"].ToString());
                flex = new FilterExpression()
                {
                    Conditions = 
                    { 
                        new ConditionExpression("cssi_designation",ConditionOperator.Equal,Pnl["cssi_designation"])
                    }

                };
            }

            QueryExpression query = new QueryExpression()
            {
                EntityName = "cssi_technicalinterviewpanel",
                ColumnSet = new ColumnSet(),
                Criteria = flex
            };

            EntityCollection results = new EntityCollection();
            results = service.RetrieveMultiple(query);
            if (results.Entities.Count > 1)
            {
                CreateLog(results.Entities.Count.ToString());
                CreateLog("contains entity returns true");
                return true;
            }
            else
            {
                CreateLog("doesnt contain entity returns false");
                return false;
            }
        }

        bool IsDuplicate(string entityname, string paramname, string paramvalue, Dictionary<string, Guid> dependents)
        {
            CreateLog("Finding Duplicates:");
            CreateLog("Entity Name:" + entityname);
            CreateLog("Parameter Name:" + paramname);
            CreateLog("Parameter Value:" + paramvalue);

            EntityCollection listrecords = new EntityCollection();
            if (!string.IsNullOrEmpty(paramvalue))
            {
                FilterExpression filterExp = new FilterExpression();
                if (entityname == "cssi_milestone")
                {
                    filterExp = new FilterExpression()
                    {
                        Conditions =
                            {
                                new ConditionExpression (paramname, ConditionOperator.Equal, paramvalue),
                                new ConditionExpression ("cssi_newprojectid", ConditionOperator.Equal, dependents["cssi_newprojectid"])
                            }
                    };
                }
                else if (entityname == "cssi_component")
                {
                    filterExp = new FilterExpression()
                    {
                        Conditions =
                            {
                                new ConditionExpression (paramname, ConditionOperator.Equal, paramvalue),
                                new ConditionExpression ("cssi_newprojectid", ConditionOperator.Equal, dependents["cssi_newprojectid"])
                            }
                    };
                }
                else if (entityname == "cssi_projectmemberroles")
                {
                    filterExp = new FilterExpression()
                    {
                        Conditions =
                            {
                                new ConditionExpression (paramname, ConditionOperator.Equal, paramvalue),
                                new ConditionExpression ("cssi_projectid", ConditionOperator.Equal, dependents["cssi_projectid"]),
                                new ConditionExpression ("cssi_roleid", ConditionOperator.Equal, dependents["cssi_roleid"])
                            }
                    };
                }

                QueryExpression query = new QueryExpression()
                {
                    EntityName = entityname,
                    ColumnSet = new ColumnSet(new string[] { paramname }),
                    Criteria = filterExp
                };

                listrecords = service.RetrieveMultiple(query);

                CreateLog("Duplicate Records Count:" + listrecords.Entities.Count.ToString());

                if (listrecords.Entities.Count > 0)
                    return true;
            }
            return false;
        }
        void CreateLog(string content)
        {
            if (isLogEnabled)
                File.AppendAllText(Logspath + @"\RestrictDuplicates.txt", DateTime.Now.ToString("dd MM yyyy HH:mm:ss fff") + "   " + content + Environment.NewLine);
        }
    }
}