using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace Model.Data
{
    public interface IProductRepository
    {
        Category GetCategoryById(int id);
        Category GetCategoryByShortName(string name);
        IEnumerable<Category> GetCategories();

        Product GetProductById(int id);
        Product GetProductByShortName(string name);
        IEnumerable<Product> GetProducts();
        IEnumerable<Product> GetProductsByCategory(int categoryId);
    }

    public class ProductRepository : IProductRepository
    {
        #region Properties

        private readonly XDocument data;
        private static string _DataFilePath =
            string.Format("{0}/App_Data/ProductData.xml", AppDomain.CurrentDomain.BaseDirectory);
        protected static string DataFilePath
        {
            get { return _DataFilePath; }
            set { _DataFilePath = value; }
        }

        #endregion

        #region Constructors

        public ProductRepository() : this(XDocument.Load(DataFilePath))
        {
            
        }
        public ProductRepository(XDocument xdoc)
        {
            data = xdoc;
        }

        #endregion

        public Category GetCategoryById(int id)
        {
            if (id == Category.All.ID)
                return Category.All;

            return (from c in data.Descendants("Category")
                    where c.Attribute<int>("ID") == id
                    select CreateCategoryFromXElement(c)).FirstOrDefault();
        }

        public Category GetCategoryByShortName(string name)
        {
            if (string.IsNullOrEmpty(name)) return null;

            if (name.Equals(Category.All.ShortName, StringComparison.OrdinalIgnoreCase))
                return Category.All;

            return (from c in data.Descendants("Category")
                    where c.Attribute<string>("ShortName").Equals(name, StringComparison.OrdinalIgnoreCase)
                    select CreateCategoryFromXElement(c)).FirstOrDefault();
        }
        
        public IEnumerable<Category> GetCategories()
        {
            var categories = (from c in data.Descendants("Category") 
                              select CreateCategoryFromXElement(c)).ToList();
            
            // Add the "All" meta-category
            categories.Insert(0, Category.All);

            return categories;
        }

        
        public Product GetProductById(int id)
        {
            return (from p in data.Descendants("Product")
                    where p.Attribute<int>("ID") == id
                    select CreateProductFromXElement(p)).FirstOrDefault();
        }

        public Product GetProductByShortName(string name)
        {
            return (from p in data.Descendants("Product")
                    where p.Attribute<string>("ShortName").Equals(name, StringComparison.OrdinalIgnoreCase)
                    select CreateProductFromXElement(p)).FirstOrDefault();
        }

        public IEnumerable<Product> GetProducts()
        {
            return (from p in data.Descendants("Product") 
                    select CreateProductFromXElement(p)).AsEnumerable();
        }

        public IEnumerable<Product> GetProductsByCategory(int categoryId)
        {
            if (categoryId == Category.All.ID) 
                return GetProducts();

            return (from p in data.Descendants("Product")
                    where p.Attribute<int>("CategoryID") == categoryId
                    select CreateProductFromXElement(p)).AsEnumerable();
        }

        #region Helpers

        protected static Category CreateCategoryFromXElement(XElement el)
        {
            return new Category
            {
                ID = el.Attribute<int>("ID"),
                Name = el.Attribute<string>("Name"),
                ShortName = el.Attribute<string>("ShortName")
            };
        }

        protected static Product CreateProductFromXElement(XElement el)
        {
            return new Product {
                                   ID = el.Attribute<int>("ID"),
                                   CategoryID = el.Attribute<int>("CategoryID"),
                                   Name = el.Attribute<string>("Name"),
                                   ShortName = el.Attribute<string>("ShortName"),
                                   Description = el.Element("Description").Value,
                                   Manufacturer = el.Attribute<string>("Manufacturer"),
                                   ImageUrl = el.Attribute<string>("ImageUrl"),
                                   UnitPrice = el.Attribute<double>("UnitPrice"),
                                   UnitsInStock = el.Attribute<int>("UnitsInStock")
                               };
        }

        #endregion

    }

    public static class XLinqExtensions
    {

        public static T Value<T>(this XElement element)
        {
            return Parse<T>(element.Value);
        }

        public static T Attribute<T>(this XElement element, string name)
        {
            var attribute = element.Attribute(name);
            return attribute != null ? Parse<T>(attribute.Value) : default(T);
        }

        private static T Parse<T>(string val)
        {
            var obj = Parse(val, typeof(T));
            return obj != null ? (T)obj : default(T);
        }

        private static object Parse(string value, Type type)
        {
            object retVal = null;

            if (type == typeof(string))
                retVal = value;
            else if (type == typeof(int))
            {
                int tmpInt;
                Int32.TryParse(value, out tmpInt);
                retVal = tmpInt;
            }
            else if (type == typeof(double))
            {
                double tmpDouble;
                Double.TryParse(value, out tmpDouble);
                retVal = tmpDouble;
            }

            return retVal;
        }
    }
}