using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using NHibernate;
using NHibernate.Linq;
using Sleis.Models;
using Sleis.Infrastructure;
using log4net;
using Sleis.Utility;
using Sleis.Data;

namespace Sleis.Service
{
    public class PageService : BaseService
    {

        public PageData PageData { get; set; }
        public PageFieldData PageFieldData { get; set; }
        public string HelpNotDefinedMessage { get; set; }
        public int DefaulthelpContentIndex { get; set; }
        public TimeSpan CacheDuration { get; set; }

        public PageService() : base()
        {
            DefaulthelpContentIndex = 999;
            HelpNotDefinedMessage = "Help content not defined";
        }
       
        public override void Init()
        {
            base.Init();
            ArgumentValidationUtility.ThrowOnNull(PageData, "PageData");
            ArgumentValidationUtility.ThrowOnNull(PageFieldData, "PageFieldData");
            ArgumentValidationUtility.ThrowOnEmpty(HelpNotDefinedMessage, "HelpNotDefinedMessage");
            ArgumentValidationUtility.ThrowOnNull(CacheDuration, "CacheDuration");
        }

        private string GetPageCacheKey(string pageKey)
        {
            return String.Format("Page-{0}", pageKey);
        }

        private string GetPageFieldCacheKey(string pageKey)
        {
            return String.Format("PageField-{0}", pageKey);
        }

        public PageModel GetOrCreatePage(string key)
        {
            ArgumentValidationUtility.ThrowOnEmpty(key, "key");

            PageModel model = CacheUtility.Get<PageModel>(GetPageCacheKey(key));

            if (model == null)
            {
                model = PageData.GetByKey(key);

                if (model == null || model.Id < 1)
                {
                    model = new PageModel();
                    model.HelpText = HelpNotDefinedMessage;
                    model.Key = key;
                    model.Title = key;
                    model.Index = DefaulthelpContentIndex;

                    PageData.Create(model);

                }

                CacheUtility.Add(GetPageCacheKey(key), model, CacheDuration);

            }

            return model;
        }


        public Dictionary<string, PageFieldModel> GetPageFields(string key)
        {
            ArgumentValidationUtility.ThrowOnEmpty(key, "key");

            //this will make sure we have the page first
            PageModel page = GetOrCreatePage(key);


            Dictionary<string, PageFieldModel> model = CacheUtility.Get<Dictionary<string, PageFieldModel>>(GetPageFieldCacheKey(page.Key));

            if (model == null || model.Count==0)
            {

                List<PageFieldModel> fields = PageFieldData.GetByPageId(page.Id);

                model = new Dictionary<string, PageFieldModel>();

                foreach (PageFieldModel field in fields)
                {
                    model.Add(field.Key, field);
                }

                CacheUtility.Add(GetPageFieldCacheKey(page.Key), model, CacheDuration);

            }

            return model;
        }
        public PageModel GetPage(int id)
        {
            PageModel page = PageData.GetById(id);
            if (page != null)
            {
                page.Fields = GetPageFields(id).OrderBy(x=>x.Title).ToList();
            }
            return page;
        }
        public List<PageFieldModel> GetPageFields(int pageId)
        {
            return PageFieldData.GetByPageId(pageId);
        }
        public void UpdatePageHelp(int pageId, string helpText)
        {
            PageModel page = GetPage(pageId);
            page.HelpText = helpText;
            PageData.SaveOrUpdate(page);
        }
        public void UpdateFieldHelp(int fieldId, string helpText)
        {
            PageFieldModel field = PageFieldData.GetById(fieldId);
            field.HelpText = helpText;
            PageFieldData.SaveOrUpdate(field);
        }
        public PageFieldModel CreateDefaultField(string pageKey, string fieldKey)
        {
            ArgumentValidationUtility.ThrowOnEmpty(pageKey, "pageKey");
            ArgumentValidationUtility.ThrowOnEmpty(fieldKey, "fieldKey");

            // incase a new value has been added during this session
            Dictionary<string, PageFieldModel> currentFields = GetPageFields(pageKey);
            PageFieldModel model = null;

            if (currentFields.ContainsKey(fieldKey))
            {
                model = currentFields[fieldKey];
            }
            else
            {

                //this will make sure we have the page first
                PageModel page = GetOrCreatePage(pageKey);

                model = new PageFieldModel();
                model.Description = "Not defined";
                model.HelpText = HelpNotDefinedMessage;
                model.Index = DefaulthelpContentIndex;
                model.Key = fieldKey;
                model.PageId = page.Id;
                model.Title = fieldKey;

                PageFieldData.Create(model);

                //Since we updated the page field content, lets remove that page frm cache
                CacheUtility.Remove(GetPageFieldCacheKey(page.Key));

                //GetPageFields(GetPageFieldCacheKey(page.Key));
                GetPageFields(page.Key);
                

            }

            return model;
        }
   
    }
}