using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using UnivateProperties_API.Containers.Property;
using UnivateProperties_API.Context;
using UnivateProperties_API.Model.Properties;

namespace UnivateProperties_API.Repository.Properties
{
    public class PropertyRepository : IPropertyRepository
    {
        private readonly DataContext dBContext;

        public PropertyRepository(DataContext _dBContext)
        {
            dBContext = _dBContext;
        }

        public List<Property> Get(Func<Property, bool> where)
        {
            return dBContext.Properties
                .Include("PropertyType")
                .Include("Province")
                .Include("City")
                .Include("Suburb")
                .Where(where).ToList();
        }

        public List<Property> GetAll()
        {
            var properties = dBContext.Properties.ToList();
            return properties;
        }

        public Property GetDetailed(Func<Property, bool> first)
        {
            var property = dBContext.Properties.Include("Status").FirstOrDefault(first);
            if (property != null)
            {
                GetDetail(ref property);
            }
            return property;
        }

        public List<Property> GetDetailedAll()
        {
            var properties = dBContext.Properties.ToList();
            return properties;
        }

        private void GetDetail(ref Property property)
        {
            int propID = property.Id;
            var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);
            property.Province = dBContext.Provinces.Find(property.ProvinceId);
            property.City = dBContext.Cities.Find(property.CityId);
            property.Suburb = dBContext.Suburbs.Find(property.SuburbId);
            property.DisplayData = new List<PropertyDetailGroup>();

            var groups = (from g in dBContext.UserDefinedGroups
                          where g.UsageType == propertyType.UsageType
                          || g.UsageType == PropertyUsageType.Both
                          orderby g.Rank
                          select g).ToList();

            foreach (UserDefinedGroup uGroup in groups)
            {
                var groupFields = (from f in dBContext.PropertyUserFields
                                   join uf in dBContext.UserDefinedFields on f.UserDefinedFieldId equals uf.Id
                                   join g in dBContext.UserDefinedGroups on uf.GroupId equals g.Id
                                   where f.PropertyId == propID
                                   && g.Id == uGroup.Id
                                   orderby g.Rank, uf.Rank
                                   select new { uf.FieldName, f.Value, f.Description }).ToList();

                if (groupFields.Count > 0)
                {
                    PropertyDetailGroup detailGroup = new PropertyDetailGroup()
                    {
                        GroupName = uGroup.Description,
                        Values = new List<PropertyDetail>()
                    };

                    if (uGroup.Description == "Property Overview")
                    {
                        detailGroup.Values.Add(new PropertyDetail()
                        {
                            Name = "Property Type",
                            Value = property.PropertyType.Description
                        });
                    }

                    foreach (var val in groupFields)
                    {
                        var irem = new PropertyDetail()
                        {
                            Name = val.FieldName,
                            Description = val.Description
                        };

                        detailGroup.Values.Add(irem);

                        if ((val.FieldName == "Erf Size" || val.FieldName == "Floor Size") && val.Value.EndsWith("2"))
                        {
                            irem.Value = val.Value.Substring(0, val.Value.Length - 1) + "<sup>" + val.Value.Last() + "</sup>";
                        }
                        else
                            irem.Value = val.Value;
                    }

                    property.DisplayData.Add(detailGroup);
                }
            }
        }

        public void Insert(Property item)
        {
            PropertyType pt = dBContext.PropertyTypes.Find(item.PropertyTypeId);
            if (pt != null)
            {
                if (pt.UsageType == PropertyUsageType.Residential)
                {
                    string type = dBContext.PropertyTypes.Find(item.PropertyTypeId).Description;
                    if (item.PropertyUserFields.Count > 0)
                    {
                        string shortDesc = "{0} {1} {2}";                        
                        UserDefinedField bedrooms = dBContext.UserDefinedFields.Where(u => u.FieldName == "Bedrooms").FirstOrDefault();
                        var udValue = item.PropertyUserFields.Where(u => u.UserDefinedFieldId == bedrooms.Id).FirstOrDefault();
                        if (udValue != null)
                            item.ShortDescription = string.Format(shortDesc, udValue.Value, "Bedroom", pt.Description).Trim();
                        else
                            item.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
                    }
                    else
                    {
                        item.ShortDescription = type;
                    }
                }
                else
                {
                    item.ShortDescription = pt.Description;
                }
            }

            var images = item.PropertyImages;
            var fields = item.PropertyUserFields;

            item.PropertyImages = null;
            item.PropertyUserFields = null;

            dBContext.Properties.Add(item);
            Save();

            if (images != null)
            {
                foreach (PropertyImage image in images)
                {
                    image.PropertyId = item.Id;
                    dBContext.PropertyImages.Add(image);
                    Save();
                }
            }

            if (fields != null)
            {
                var lastID = (from p in dBContext.PropertyUserFields
                              orderby p.Id descending
                              select p.Id).FirstOrDefault();

                foreach (PropertyUserField field in fields)
                {
                    lastID++;
                    field.Id = lastID;
                    field.PropertyId = item.Id;
                    dBContext.PropertyUserFields.Add(field);
                    Save();
                }
            }
        }

        public void Insert(IEnumerable<Property> items)
        {
            foreach (var item in items)
            {
                dBContext.Properties.Add(item);
            }
            Save();
        }

        public void Remove(Property item)
        {
            dBContext.Properties.Remove(item);
            Save();
        }

        public void Remove(IEnumerable<Property> items)
        {
            foreach (var item in items)
            {
                dBContext.Properties.Remove(item);
            }
            Save();
        }

        public void RemoveAtId(int item)
        {
            var property = Get(x => x.Id == item).FirstOrDefault();
            if (property != null)
            {
                dBContext.Properties.Remove(property);
                Save();
            }
        }

        public void Save()
        {
            dBContext.SaveChanges();
        }

        public void Update(Property item)
        {
            dBContext.Entry(item).State = EntityState.Modified;
            Save();
        }

        public List<PropertyDisplay> GetDisplay()
        {
            List<Property> props = GetAll();
            return GetDisplayDetails(props);
        }

        public List<PropertyDisplay> GetDisplay(Func<Property, bool> where)
        {
            List<Property> props;
            if (where != null)
                props = Get(where);
            else
                props = GetAll();

            return GetDisplayDetails(props);
        }

        public List<PropertyDisplay> GetDisplay(PropertySearch search)
        {
            //Save to Log
            dBContext.SearchLogs.Add(new Model.Logging.SearchLog()
            {
                Type = "Property",
                Search = JsonConvert.SerializeObject(search)
            });
            Save();

            if (!string.IsNullOrEmpty(search.Keyword) && search.Keyword.ToUpper() != "ALL")
            {
                string keyword = search.Keyword.ToLower();

                List<Property> props = (from p in dBContext.Properties
                                        join pr in dBContext.Provinces on p.ProvinceId equals pr.Id
                                        join c in dBContext.Cities on p.CityId equals c.Id
                                        join s in dBContext.Suburbs on p.SuburbId equals s.Id
                                        join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
                                        where EF.Functions.Like(p.PropertyName.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(pr.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(c.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(s.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(pt.Description.ToLower(), $"%{keyword}%")
                                        select p).ToList();

                return GetDisplayDetails(props);
            }
            else
            {
                List<Property> props;
                PropertyUsageType uType = PropertyUsageType.Both;

                if (!string.IsNullOrEmpty(search.PropertyUsageType) && search.PropertyUsageType != "undefined")
                {
                    if (search.PropertyUsageType.ToUpper() == "COMMERCIAL")
                        uType = PropertyUsageType.Commercial;
                    else
                        uType = PropertyUsageType.Residential;
                }
                props = (from p in dBContext.Properties
                         join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
                         where pt.UsageType == uType
                         select p).ToList();

                if (!string.IsNullOrEmpty(search.SalesType) && search.SalesType != "undefined" && search.SalesType.ToUpper() != "ALL")
                {
                    if (search.SalesType.ToUpper() == "SALE")
                        props = props.Where(p => p.IsSale).ToList();
                    else
                        props = props.Where(p => !p.IsSale).ToList();
                }

                if (!string.IsNullOrEmpty(search.Province) && search.Province != "undefined" && search.Province.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join pp in dBContext.Provinces on p.ProvinceId equals pp.Id
                             where pp.Description.ToUpper() == search.Province.ToUpper()
                             select p).ToList();
                }

                if (!string.IsNullOrEmpty(search.City) && search.City != "undefined" && search.City.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join c in dBContext.Cities on p.CityId equals c.Id
                             where c.Description.ToUpper() == search.City.ToUpper()
                             select p).ToList();
                }

                if (!string.IsNullOrEmpty(search.Suburb) && search.Suburb != "undefined" && search.Suburb.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join s in dBContext.Suburbs on p.SuburbId equals s.Id
                             where s.Description.ToUpper() == search.Suburb.ToUpper()
                             select p).ToList();
                }
                if (!string.IsNullOrEmpty(search.PropertyType) && search.PropertyType != "Undefined" && search.PropertyType.ToUpper() != "ALL")
                {
                    var pType = dBContext.PropertyTypes.Where(t => t.Description == search.PropertyType).FirstOrDefault();
                    if (pType != null)
                    {
                        props = props.Where(p => p.PropertyTypeId == pType.Id).ToList();
                    }
                }

                return GetDisplayDetails(props);
            }
        }        

        private List<PropertyDisplay> GetDisplayDetails(List<Property> props)
        {
            var properties = new List<PropertyDisplay>();
            foreach (var item in props)
            {
                PropertyDisplay display = new PropertyDisplay
                {
                    Id = item.Id,
                    ShortDescription = item.ShortDescription,
                    IsSale = item.IsSale,
                    DisplayPrice = string.Format("R {0}", item.Price.ToString("N0")),
                    DisplayImage = (from i in dBContext.PropertyImages
                                    where i.PropertyId == item.Id
                                    && i.IsDefault
                                    select i.Image).FirstOrDefault(),
                    Area = (from u in dBContext.PropertyUserFields
                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                            where u.PropertyId == item.Id
                            && f.FieldName == "Floor Size"
                            select u.Value).FirstOrDefault(),
                    Beds = (from u in dBContext.PropertyUserFields
                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                            where u.PropertyId == item.Id
                            && f.FieldName == "Bedrooms"
                            select u.Value).FirstOrDefault(),
                    Baths = (from u in dBContext.PropertyUserFields
                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                             where u.PropertyId == item.Id
                             && f.FieldName == "Bathrooms"
                             select u.Value).FirstOrDefault(),
                    Garages = (from u in dBContext.PropertyUserFields
                               join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                               where u.PropertyId == item.Id
                               && f.FieldName == "Garages"
                               select u.Value).FirstOrDefault(),
                    Province = (from p in dBContext.Provinces
                                where p.Id == item.ProvinceId
                                select p.Description).FirstOrDefault(),
                    City = (from c in dBContext.Cities
                            where c.Id == item.CityId
                            select c.Description).FirstOrDefault(),
                    Suburb = (from s in dBContext.Suburbs
                              where s.Id == item.SuburbId
                              select s.Description).FirstOrDefault(),
                    Price = item.Price,
                    DateCreated = item.Created
                };

                if (!string.IsNullOrEmpty(display.Area) && display.Area.EndsWith("2"))
                {
                    display.Area = display.Area.Substring(0, display.Area.Length - 1) + "<sup>" + display.Area.Last() + "</sup>";
                }

                properties.Add(display);
            }

            return properties;
        }

        public List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where)
        {
            List<PropertyType> list;
            if (where != null)
                list = dBContext.PropertyTypes.Where(where).ToList();
            else
                list = dBContext.PropertyTypes.ToList();

            return list;
        }

        public List<PropertyDisplay> GetLatestDisplay()
        {
            List<Property> props = GetAll().OrderBy(x => x.Created).Take(3).ToList();
            return GetDisplayDetails(props);
        }

        public List<PropertyList> GetPropertyList(Func<Property, bool> where)
        {
            var properties = Get(where);

            List<PropertyList> list = new List<PropertyList>();

            foreach (Property p in properties)
            {
                var prop = new PropertyList()
                {
                    Id = p.Id,
                    Name = string.IsNullOrEmpty(p.PropertyName) ? p.ShortDescription : p.PropertyName,
                    Price = string.Format("R {0:n}", p.Price),
                    Publish = p.Published.ToString(),
                    Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description
                };

                prop.Size = (from u in dBContext.PropertyUserFields
                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                             where u.PropertyId == p.Id
                             && f.FieldName == "Floor Size"
                             select u.Value).FirstOrDefault();

                if (!string.IsNullOrEmpty(prop.Size) && prop.Size.EndsWith("2"))
                {
                    prop.Size = prop.Size.Substring(0, prop.Size.Length - 1) + "<sup>" + prop.Size.Last() + "</sup>";
                }

                list.Add(prop);
            }
                
            return list;
        }       
    }
}