using Microsoft.Office.Interop.Word;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace JRCookbookBusiness
{
    public class IngredientUsage
    {
        public Guid? ingredientUsageID = null;
        public string normalizedIngredientName = string.Empty;
        public Guid? ingredientID = null;
        public Int32 usageCount = 0;
        private string retrievedIngredientName = string.Empty;

        private static List<IngredientUsage> _allIngredientUsage = null;

        public IngredientUsage()
        {
        }

        public IngredientUsage(Guid ingredientUsageID)
        {
            PopulateByID(ingredientUsageID);
        }

        public IngredientUsage(DataRow dataRow)
        {
            PopulateFromDataRow(dataRow);
        }

        public IngredientUsage(string normalizedIngredientName, Guid ingredientID)
        {
            PopulateByNameAndIngredientID(normalizedIngredientName, ingredientID);
        }

        public static IngredientUsage GetIngredientUsageByID(Guid ingredientUsageID)
        {
            return new IngredientUsage(ingredientUsageID);
        }

        public static IngredientUsage GetIngredientUsageByNameAndIngredientID(string normalizedIngredientName, Guid ingredientID)
        {
            return new IngredientUsage(normalizedIngredientName, ingredientID);
        }

        private void PopulateByID(Guid ingredientUsageID)
        {
            DataSet recordSet;

            recordSet = clsDatabaseLayer.GetDatabaseLayer().GetIngredientUsageByID(ingredientUsageID);

            if (recordSet.Tables[0].Rows.Count > 0)
            {
                DataRow ldbrwRow;
                ldbrwRow = recordSet.Tables[0].Rows[0];

                PopulateFromDataRow(ldbrwRow);
            }

        }

        private void PopulateByNameAndIngredientID(string normalizedIngredientName, Guid ingredientID)
        {
            DataSet recordSet;

            recordSet = clsDatabaseLayer.GetDatabaseLayer().GetIngredientUsageByNameAndIngredientID(normalizedIngredientName, ingredientID);

            if (recordSet.Tables[0].Rows.Count > 0)
            {
                DataRow ldbrwRow;
                ldbrwRow = recordSet.Tables[0].Rows[0];

                PopulateFromDataRow(ldbrwRow);
            }

        }

        public static Int32 GetIngredientUsageCount(Ingredient ingredient)
        {
            var getUsage = GetIngredientUsageAll();

            Int32 totalUsageCount = 0;

            foreach(var ingredientUsage in getUsage)
            {
                if (ingredientUsage.ingredientID == ingredient.ingredientID)
                {
                    totalUsageCount += ingredientUsage.usageCount;
                }
            }

            return totalUsageCount;
        }

        public static List<IngredientUsage> GetIngredientUsageAll()
        {
            if (_allIngredientUsage == null)
            {
                _allIngredientUsage = new List<IngredientUsage>();

                DataSet recordSet;

                recordSet = clsDatabaseLayer.GetDatabaseLayer().GetIngredientUsageAll();

                foreach (DataRow dataRow in recordSet.Tables[0].Rows)
                {
                    var ingredientUsage = new IngredientUsage(dataRow);
                    _allIngredientUsage.Add(ingredientUsage);
                }
            }

            _allIngredientUsage.Sort(CompareIngredientByUsage);
            return _allIngredientUsage;
        }

        private static int CompareIngredientByUsage(IngredientUsage x, IngredientUsage y)
        {
            if (x == null)
            {
                if (y == null)
                {
                    // If x is null and y is null, they're
                    // equal.
                    return 0;
                }
                else
                {
                    // If x is null and y is not null, y
                    // is greater.
                    return -1;
                }
            }
            else
            {
                // If x is not null...
                //
                if (y == null)
                // ...and y is null, x is greater.
                {
                    return 1;
                }
                else
                {
                    // ...and y is not null, compare the usage count
                    //
                    int retval = -1 * x.usageCount.CompareTo(y.usageCount);

                    if (retval != 0)
                    {
                        // If the usageCounts are different,
                        // return that the higher count should be first
                        //
                        return retval;
                    }
                    else
                    {
                        // If the usageCounts are the same,
                        // sort them with ordinary string comparison.
                        //
                        return x.retrievedIngredientName.CompareTo(y.retrievedIngredientName);
                    }
                }
            }
        }


        public static IngredientUsage GetIngredientUsageByDataRow(DataRow row)
        {
            var newIngredientUsage = new IngredientUsage();
            newIngredientUsage.PopulateFromDataRow(row);
            return newIngredientUsage;
        }

        private void PopulateFromDataRow(DataRow dataRow)
        {
            InitializeAllFields();

            if (dataRow.IsNull("ingredientUsageID"))
                ingredientUsageID = null;
            else
                ingredientUsageID = (Guid)dataRow["ingredientUsageID"];

            if (dataRow.IsNull("normalizedIngredientName"))
                normalizedIngredientName = null;
            else
                normalizedIngredientName = (String)dataRow["normalizedIngredientName"];

            if (dataRow.IsNull("ingredientID"))
                ingredientID = null;
            else
                ingredientID = (Guid)dataRow["ingredientID"];

            if (dataRow.IsNull("usageCount"))
                usageCount = 0;
            else
                usageCount = (Int32)dataRow["usageCount"];

            if (ingredientID != null)
            {
                retrievedIngredientName = Ingredient.GetIngredientByID(ingredientID.Value).name;
            }
        }

        private void InitializeAllFields()
        {
            ingredientUsageID = null;
            normalizedIngredientName = String.Empty;
            ingredientID = null;
            usageCount = 0;
        }

        public void Save()
        {
            if (this.ingredientUsageID == null)
            {
                this.ingredientUsageID = clsDatabaseLayer.GetDatabaseLayer().GetNewIDIngredientUsage();
                clsDatabaseLayer.GetDatabaseLayer().InsertIngredientUsage(this);
            }
            else
            {
                clsDatabaseLayer.GetDatabaseLayer().UpdateIngredientUsage(this);
            }
        }


        public static void RebuildIngredientUsage()
        {
            clsDatabaseLayer.GetDatabaseLayer().DeleteIngredientUsageAll();
            List<IngredientUsage> newList = new List<IngredientUsage>();
            var allRecipeIngredients = RecipeIngredient.GetRecipeIngredientAll();
            foreach(RecipeIngredientItem recipeIngredient in allRecipeIngredients)
            {
                var normalizedIngredientName = RecipeIngredient.NormalizeRecipeIngredientName(recipeIngredient.ingredientText);

                bool foundMatch = false;

                foreach(var ingredientUsage in newList)
                {
                    if (ingredientUsage.normalizedIngredientName == normalizedIngredientName && ingredientUsage.ingredientID == recipeIngredient.ingredientID)
                    {
                        foundMatch = true;
                        ingredientUsage.usageCount++;
                    }
                }

                if (!foundMatch)
                {
                    var newIngredientUsage = new IngredientUsage();
                    newIngredientUsage.normalizedIngredientName = normalizedIngredientName;
                    newIngredientUsage.ingredientID = ((RecipeIngredientItem)recipeIngredient).ingredientID;
                    newIngredientUsage.usageCount = 1;

                    newList.Add(newIngredientUsage);
                }
            }

            foreach(var ingredient in newList)
            {
                ingredient.Save();
            }

        }
    }
}