using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;

namespace DragoonService
{
    public class Controller : IController
    {
        private readonly DataModelContainer _db;

        public Controller()
        {
            _db = new DataModelContainer();
            _db.Database.Initialize(false);
        }


        public ELoginResult Login(string username, string password)
        {
            return _db.Logins.Any(login => login.Name == username && login.Password == password) ? ELoginResult.Success : ELoginResult.Failed;
        }

        public ERegisterResult Register(string username, string password)
        {
            if (!_db.Logins.Any(login => login.Name == username))
            {
                _db.Logins.Add(new Login {IsAdmin = false, Name = username, Password = password});
                _db.SaveChanges();
                return ERegisterResult.Success;
            }
            return ERegisterResult.UsernameExists;
        }

        public List<CompactHighscore> GetHighscores()
        {
            return _db.Highscores.Select(highscore => new CompactHighscore { Id = highscore.Id, Name = highscore.Name, Score = highscore.Score, Level = highscore.Level.Id}).ToList();
        }

        public EActionResult AddHighscore(CompactHighscore highscore)
        {
            _db.Highscores.Add(new Highscore
                                   {
                                       Level = _db.Levels.FirstOrDefault(l => l.Id == highscore.Level),
                                       Login = _db.Logins.FirstOrDefault(login => login.Name == highscore.Name)
                                   });
            _db.SaveChanges();
            return EActionResult.Success;
        }

        public List<CompactLevel> GetLevels()
        {
            return _db.Levels.Select(level => new CompactLevel { Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version, XML = level.XML}).ToList();
        }

        public List<CompactLevel> GetLevelsByName(string name)
        {
            return _db.Levels.Where(l => l.Name == name).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public CompactLevel GetLevelByNameAndVersion(string name, double version)
        {
            var level = _db.Levels.First(l => l.Name == name && l.MapVersion.Version == version);
            return new CompactLevel
                       {
                           Id = level.Id,
                           Name = level.Name,
                           Author = level.Author,
                           MapType = level.MapType,
                           Version = level.MapVersion.Version,
                           XML = level.XML,
                       };
        }

        public CompactLevel GetLevelById(int id)
        {
            var level = _db.Levels.First(l => l.Id == id);
            return new CompactLevel
                       {
                           Author = level.Author,
                           Id = level.Id,
                           MapType = level.MapType,
                           Name = level.Name,
                           Version = level.MapVersion.Version,
                           XML = level.XML,
                       };
        }

        public EActionResult AddLevel(CompactLevel level, bool overwriteIfExists, bool allowOfficialVSUnofficalDuplicate)
        {
            if (_db.Levels.Any(l => l.Name == level.Name && level.Version == l.MapVersion.Version))
            {
                if (!_db.Levels.Any(l => l.MapType == level.MapType))
                {
                    if (allowOfficialVSUnofficalDuplicate)
                    {
                        _db.Levels.Add(new Level
                                           {
                                               Author = level.Author,
                                               MapType = level.MapType,
                                               MapVersion =
                                                   _db.MapVersions.FirstOrDefault(mv => mv.Version == level.Version),
                                               Name = level.Name,
                                               XML = level.XML
                                           });
                    }
                }
                else if (overwriteIfExists)
                {
                    _db.Levels.Remove(
                        _db.Levels.FirstOrDefault(
                            l =>
                            l.Name == level.Name && level.Version == l.MapVersion.Version && l.MapType == level.MapType));
                    _db.Levels.Add(new Level
                                       {
                                           Author = level.Author,
                                           MapType = level.MapType,
                                           MapVersion =
                                               _db.MapVersions.FirstOrDefault(mv => mv.Version == level.Version),
                                           Name = level.Name,
                                           XML = level.XML
                                       });
                }

            }
            else
            {
                _db.Levels.Add(new Level
                {
                    Author = level.Author,
                    MapType = level.MapType,
                    MapVersion =
                        _db.MapVersions.FirstOrDefault(mv => mv.Version == level.Version),
                    Name = level.Name,
                    XML = level.XML
                });
            }
            _db.SaveChanges();
            return EActionResult.Success;
        }


        public List<CompactLevel> GetDefaultLevels()
        {
            return _db.Levels.Where(l => l.MapType == EMapType.Default).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public List<CompactLevel> GetCustomLevels()
        {
            return _db.Levels.Where(l => l.MapType == EMapType.Custom).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public List<CompactLevel> GetDefaultLevelByName(string name)
        {
            return _db.Levels.Where(l => l.MapType == EMapType.Default && l.Name == name).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public CompactLevel GetDefaultLevelByNameAndVersion(string name, double version)
        {
            var level = _db.Levels.FirstOrDefault(
                l => l.MapType == EMapType.Default && l.Name == name && l.MapVersion.Version == version);
            return new CompactLevel
                       {
                           Id = level.Id,
                           Name = level.Name,
                           Author = level.Author,
                           MapType = level.MapType,
                           Version = level.MapVersion.Version,
                           XML = level.XML
                       };
        }

        public List<CompactLevel> GetCustomLevelByName(string name)
        {
            return _db.Levels.Where(l => l.MapType == EMapType.Custom && l.Name == name).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public CompactLevel GetCustomLevelByNameAndVersion(string name, double version)
        {
            var level = _db.Levels.FirstOrDefault(
                    l => l.MapType == EMapType.Custom && l.Name == name && l.MapVersion.Version == version);
            return new CompactLevel
            {
                Id = level.Id,
                Name = level.Name,
                Author = level.Author,
                MapType = level.MapType,
                Version = level.MapVersion.Version,
                XML = level.XML,
            };
        }

        public List<CompactLevel> GetLevelsByType(EMapType mapType)
        {
            return _db.Levels.Where(l => l.MapType == mapType).Select(level => new CompactLevel { XML = level.XML, Id = level.Id, Name = level.Name, Author = level.Author, MapType = level.MapType, Version = level.MapVersion.Version }).ToList();
        }

        public EActionResult DeleteLevelById(int id)
        {
            _db.Levels.Remove(_db.Levels.FirstOrDefault(l => l.Id == id));
            _db.SaveChanges();
            return EActionResult.Success;
        }

        public EActionResult DeleteLevelByNameAndType(string name, EMapType mapType)
        {
            var toDelete = _db.Levels.Where(l => l.Name == name && l.MapType == mapType);
            foreach (var level in toDelete)
            {
                _db.Levels.Remove(level);
            }
            return EActionResult.Success;
        }

        public bool IsAdmin(string name)
        {
            return _db.Logins.Any(l => l.Name == name && l.IsAdmin);
        }

        public EAdminVerifyResult RegisterAsAdmin(string name, string adminkey)
        {
            throw new System.NotImplementedException();
        }

        public CompactGameVersion GetCurrentGameVersion()
        {
            var versions = _db.GameVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            return new CompactGameVersion
                       {Id = wanted.Id, Version = wanted.Version, Time = wanted.Time, URL = wanted.URL, LauncherVersionId = wanted.LauncherVersion.Id, MapVersionId = wanted.MapVersions.Id };
        }

        public CompactLauncherVersion GetCurrentLauncherVersion()
        {
            var versions = _db.LauncherVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            var list = wanted.GameVersions.Select(gv => gv.Id).ToList();
            return new CompactLauncherVersion { Id = wanted.Id, Version = wanted.Version, Time = wanted.Time, URL = wanted.URL, GameVersionIds = list  };
        }

        public bool IsGameCurrentVersion(double currentVersion)
        {
            var versions = _db.GameVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            return currentVersion == wanted.Version;
        }

        public bool IsLauncherCurrentVersion(double currentVersion)
        {
            var versions = _db.LauncherVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            return currentVersion == wanted.Version;
        }

        public string GetGameUpdateUrl()
        {
            var versions = _db.GameVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            return wanted.URL;
        }

        public string GetLauncherUpdateUrl()
        {
            var versions = _db.LauncherVersions;
            var sortedVersions = versions.OrderBy(v => v.Version).Reverse();
            var wanted = sortedVersions.FirstOrDefault();
            return wanted.URL;
        }

        public List<CompactGameVersion> GetGameVersions()
        {
            return _db.GameVersions.Select(gv => new CompactGameVersion{ Id = gv.Id, LauncherVersionId =  gv.LauncherVersion.Id, MapVersionId = gv.MapVersions.Id, Time = gv.Time, URL = gv.URL, Version = gv.Version}).ToList();
        }

        public List<CompactMapVersion> GetMapVersions()
        {
            List<CompactMapVersion> toReturn = new List<CompactMapVersion>();
            foreach (var mv in _db.MapVersions)
            {
                List<int> gameversions = mv.GameVersion.Select(gameversion => gameversion.Id).ToList();
                List<int> levels = mv.Level.Select(l => l.Id).ToList();
                toReturn.Add(new CompactMapVersion
                                 {
                                     Id = mv.Id,
                                     GameVersionIds = gameversions,
                                     LevelIds = levels,
                                     Time = mv.Time,
                                     Version = mv.Version
                                 });
            }
            return toReturn;
        }

        public List<CompactLauncherVersion> GetLauncherVersions()
        {
            var list = (from v in _db.LauncherVersions from gv in v.GameVersions select gv.Id).ToList();
            return _db.LauncherVersions.Select(lv => new CompactLauncherVersion { Id = lv.Id, GameVersionIds = list, Time = lv.Time, URL = lv.URL, Version = lv.Version }).ToList();

        }

        public EActionResult AddNewGameVersion(CompactGameVersion newVersion)
        {
            _db.GameVersions.Add(new GameVersion
                                     {
                                         LauncherVersion =
                                             _db.LauncherVersions.FirstOrDefault(
                                                 lv => lv.Id == newVersion.LauncherVersionId),
                                         MapVersions =
                                             _db.MapVersions.FirstOrDefault(lv => lv.Id == newVersion.MapVersionId),
                                         Time = newVersion.Time,
                                         URL = newVersion.URL,
                                         Version = newVersion.Version
                                     });
            _db.SaveChanges();
            return EActionResult.Success;
        }

        public EActionResult AddNewLauncherVersion(CompactLauncherVersion newVersion)
        {
            var list = (from gameVersion in _db.GameVersions from version in newVersion.GameVersionIds where gameVersion.Id == version select gameVersion).ToList();
            ;
            List<GameVersion> gameVersions = list;
            _db.LauncherVersions.Add(new LauncherVersion
            {
                Time = newVersion.Time,
                URL = newVersion.URL,
                Version = newVersion.Version,
                GameVersions = gameVersions,
            });
            _db.SaveChanges();
            return EActionResult.Success;
        }

        public EActionResult AddNewMapVersion(CompactMapVersion newVersion)
        {
            List<Level> levels = (from level in _db.Levels from l in newVersion.LevelIds where level.Id == l select level).ToList();
            List<GameVersion> gameVersions = (from gameVersion in _db.GameVersions from version in newVersion.GameVersionIds where gameVersion.Id == version select gameVersion).ToList();
            _db.MapVersions.Add(new MapVersion
            {
                Time = newVersion.Time,
                GameVersion = gameVersions,
                Version = newVersion.Version,
                Level = levels,
            });
            _db.SaveChanges();
            return EActionResult.Success;
        }
    }
}