using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using Pinwheel.Reporting;

namespace Pinwheel.Data
{
    public class LinqToSqlDataService : IAwardService, IRulesService, IAwardReportService
    {
        internal const string DEFAULT_CONNECTION_NAME = "AwardsService";

        private bool? _ShouldCreateDatabase;
        public bool ShouldCreateDatabase
        {
            get
            {
                if (!_ShouldCreateDatabase.HasValue)
                {
                    var val = ConfigurationManager.AppSettings["CreateDatabase"];
                    _ShouldCreateDatabase = !string.IsNullOrEmpty(val) && Boolean.Parse(val);
                }

                return _ShouldCreateDatabase.Value;
            }
            set { _ShouldCreateDatabase = value; }
        }

        public string ConnectionString { get; set; }

        public LinqToSqlDataService()
            : this(DEFAULT_CONNECTION_NAME)
        {
        }

        public LinqToSqlDataService(string connectionName)
        {
            ConnectionString = ConfigurationManager
                        .ConnectionStrings[connectionName].ConnectionString;
        }

        public void BestowAward(Award award)
        {
            var dbAward = new LinqAward
            {
                AwardType = award.GetType().AssemblyQualifiedName,
                CreateDate = award.Timestamp,
                Username = award.User.Username
            };

            using (var context = GetContext())
            {
                context.LinqAwards.InsertOnSubmit(dbAward);
                context.SubmitChanges();
            }
        }

        public void RegisterRule<T>() where T : IAwardRule
        {
            var type = typeof(T);
            using (var context = GetContext())
            {
                var ruleExists = (from r in context.LinqAwardRules
                                  where r.TypeName == type.AssemblyQualifiedName
                                  select r).Count() > 0;

                if (ruleExists) return;

                var rule = new LinqAwardRule
                {
                    Name = type.Name,
                    TypeName = type.AssemblyQualifiedName
                };
                context.LinqAwardRules.InsertOnSubmit(rule);
                context.SubmitChanges();
            }
        }

        public IEnumerable<IAwardRule> GetRules()
        {
            var context = GetContext();
            return from r in context.LinqAwardRules
                   select r.ToIAwardRule();
        }

        public IEnumerable<User> GetUsers()
        {
            var context = GetContext();
            var usernames = (from a in context.LinqAwards
                             select a.Username).Distinct();
            return from u in usernames
                   select new User { Username = u };
        }

        public AwardReport GetAwardReport(string userID)
        {
            var context = GetContext();
            return new AwardReport(
                from a in context.LinqAwards
                where a.Username == userID
                group a by a.AwardType into t
                select new AwardSummary(Type.GetType(t.Key, true, true), (int)t.Count(), null)
            );
        }

        public AwardSummary<T> GetAwardSummary<T>(string userID) where T : Award
        {
            throw new System.NotImplementedException();
        }

        protected AwardsRepositoryDataContext GetContext()
        {
            var context = new AwardsRepositoryDataContext(ConnectionString);
            if (!context.DatabaseExists() && ShouldCreateDatabase)
                context.CreateDatabase();
            return context;
        }

    }
}