using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using DuckEmulator.HabboHotel.Inside.Storage.MySql.Database.Interfaces;
using DuckEmulator.HabboHotel.Outside.Messages.Types;
using DuckEmulator.HabboHotel.Outside.Habbos;

namespace DuckEmulator.HabboHotel.Outside.Achievements
{
    class AchievementManager
    {
        internal Dictionary<uint, Achievement> Achievements;
        internal List<AchievementData> AchievementData;

        internal AchievementManager()
        {
            LoadAchievements();
            LoadAchievementData();
        }

        internal void LoadAchievements()
        {
            Achievements = new Dictionary<uint, Achievement>();

            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT * FROM achievements ORDER BY order_num ASC");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                Achievements.Add((uint)Row["id"],new Achievement(
                    (uint)Row["id"],
                    GetType((int)Row["type"]),
                    (int)Row["levels"],
                    Row["badgecode"].ToString(),
                    (Row["multiplay"].ToString() == "1"),
                    (int)Row["pixelreward"],
                    (double)Row["doubler"]));
                    
            }

            DuckEnvironment.WriteLine("Loaded " + Achievements.Count + " achievements.", ConsoleColor.Yellow);
        }

        internal void LoadAchievementData()
        {
            AchievementData = new List<AchievementData>();

            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT * FROM achievements_data");
                Data = Adapter.getTable();
            }

            if (Data == null) return;

            foreach (DataRow Row in Data.Rows)
            {
                AchievementData.Add(new AchievementData((uint)Row["achievement_id"], (int)Row["level"], (int)Row["need"]));
            }

            DuckEnvironment.WriteLine("Loaded " + AchievementData.Count + " achievementdata.", ConsoleColor.Yellow);
        }

        internal ServerMessage Serialize(HabboData Habbo)
        {
            if (Habbo == null)
            {
                return null;
            }

            var UserAchievements = Habbo.Achievements;

            ServerMessage Message = new ServerMessage(436);

            Message.AppendInt32(Achievements.Count);

            foreach (Achievement Achievement in Achievements.Values.ToList())
            {
                int CurrentLevel = ((UserAchievements.ContainsKey(Achievement.Id)) ? UserAchievements[Achievement.Id] : 0);
                int NextLevel = (CurrentLevel + 1); if (NextLevel > Achievement.Levels) NextLevel = Achievement.Levels;
                int Got = GetHave(Achievement.Id, Habbo);
                int Need = GetNeed(Achievement.Id, NextLevel);

                Message.AppendUInt(Achievement.Id);
                Message.AppendInt32(NextLevel);
                Message.AppendStringWithBreak((Achievement.MultiPlay) ? Achievement.BadgeCode + NextLevel : Achievement.BadgeCode);
                Message.AppendInt32(Need); // need count
                Message.AppendInt32((int)(Achievement.PixelReward * NextLevel * Achievement.Doubler));
                Message.AppendBoolean(false);
                Message.AppendInt32(Got); // got count
                Message.AppendBoolean(CurrentLevel >= Achievement.Levels);
                Message.AppendStringWithBreak(Achievement.AchievementType.ToString().ToLower());
                Message.AppendInt32(Achievement.Levels);
            }

            Message.AppendStringWithBreak("");

            return Message;
        }

        internal void UpdateAchievement(HabboData Habbo, uint AchievementId)
        {
            if (Habbo == null)
            {
                return;
            }

            var UserAchievements = Habbo.Achievements;

            Achievement Achievement = GetAchievement(AchievementId);
            if (Achievement == null) return;

            ServerMessage Message = new ServerMessage(913);

            int CurrentLevel = ((UserAchievements.ContainsKey(Achievement.Id)) ? UserAchievements[Achievement.Id] : 0);
            int NextLevel = (CurrentLevel + 1);

            if (NextLevel > Achievement.Levels)
            {
                NextLevel = Achievement.Levels;
            }

            if (CurrentLevel == Achievement.Levels)
            {
                return;
            }

            int Got = GetHave(AchievementId, Habbo);
            int Need = GetNeed(AchievementId, NextLevel);

            Message.AppendUInt(Achievement.Id);
            Message.AppendInt32(NextLevel);
            Message.AppendStringWithBreak((Achievement.MultiPlay) ? Achievement.BadgeCode + NextLevel : Achievement.BadgeCode);
            Message.AppendInt32(Need); // needcount
            Message.AppendInt32((int)(Achievement.PixelReward * NextLevel * Achievement.Doubler));
            Message.AppendBoolean(false);
            Message.AppendInt32(Got); // gotcount
            Message.AppendBoolean(CurrentLevel >= Achievement.Levels);
            Message.AppendStringWithBreak(Achievement.AchievementType.ToString().ToLower());
            Message.AppendInt32(Achievement.Levels);

            if (Got >= Need)
            {
                UnlockAchievement(Habbo, AchievementId, NextLevel);
            }

            Habbo.SendResponse(Message);
        }

        internal void UnlockAchievement(HabboData Habbo, uint AchievementId, int Level)
        {
            if (Habbo == null)
            {
                return;
            }

            Achievement Achievement = GetAchievement(AchievementId);

            if (Achievement == null)
            {
                return;
            }

            if (!Habbo.Achievements.ContainsKey(AchievementId))
            {
                Habbo.Achievements.Add(AchievementId, 1);

                Habbo.GetBadgeTable().GiveBadge(GenerateBadgeCode(Achievement, (Level)), true);
                Habbo.Score += (100 * Level / 2);

                using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
                {
                    Adapter.setQuery("SELECT id FROM user_achievements  WHERE user_id = '" + Habbo.Id + "' AND achievement_id = '" + AchievementId + "' LIMIT 1");
                    bool Contains = (Adapter.getString() != "");

                    if (!Contains)
                    {
                        Adapter.runFastQuery("INSERT INTO user_achievements (user_id,achievement_id,level) VALUES ('" + Habbo.Id + "','" + AchievementId + "','" + Level + "')");
                    }
                }
            }
            else if (Habbo.Achievements[AchievementId] < Level)
            {
                if (Habbo.Achievements[AchievementId] < Achievement.Levels)
                {
                    Habbo.Achievements[AchievementId] = Level;

                    Habbo.GetBadgeTable().EditBadge(GenerateBadgeCode(Achievement, (Level - 1)), GenerateBadgeCode(Achievement, (Level)));
                    Habbo.Score += (100 * Level / 2);

                    using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
                    {
                        Adapter.runFastQuery("UPDATE user_achievements SET level = '" + Level + "' WHERE user_id = '" + Habbo.Id + "' AND achievement_id = '" + AchievementId + "' LIMIT 1");
                    }
                }
                else
                {
                    return;
                }
            }
            else
            {
                return;
            }

            int OldLevelGen = (Level - 1);

            if (OldLevelGen == 0)
            {
                OldLevelGen = 1;
            }

            Habbo.UpdateVariable("score", Habbo.Score);
            Habbo.UpdatePixels(Achievement.PixelReward, true);

            Habbo.GetConnection().GetClient().GetMessageHandler().GetAchievementScore();

            ServerMessage Message = new ServerMessage(437);
            Message.AppendUInt(Achievement.Id);
            Message.AppendInt32(Level);
            Message.AppendInt32(2052);
            Message.AppendStringWithBreak(Achievement.BadgeCode + Level);
            Message.AppendInt32(10); //achievescore
            Message.AppendInt32(Achievement.PixelReward);
            Message.AppendBoolean(false); // got
            Message.AppendInt32(10); //achievescore
            Message.AppendInt32(368); // idk
            Message.AppendStringWithBreak(Achievement.BadgeCode + OldLevelGen);
            Message.AppendStringWithBreak(Achievement.AchievementType.ToString().ToLower());

            Habbo.SendResponse(Message);

            Habbo.GetMessenger().BroadcastAchievement(Achievement.BadgeCode + Level.ToString(), true);
            Habbo.RefreshUserDetails();
        }

        internal int GetNeed(uint AchievementId, int Level)
        {
            foreach (AchievementData Data in AchievementData)
            {
                if (Data.AchievementId == AchievementId)
                {
                    if (Data.Level == Level)
                    {
                        return Data.Amout;
                    }
                }
            }

            return 1;
        }

        internal int GetHave(uint AchievementId, HabboData Habbo)
        {
            switch (AchievementId)
            {
                case 2:
                    return Habbo.Tags.Count;
                case 3:
                    return Habbo.FollowingLogins;
                case 6:
                    return Habbo.TimeOnline;
                case 104:
                    return Habbo.RoomVisits;
                case 105:
                    return Habbo.IceTagTime;
                case 108:
                    return Habbo.RespectGiven;
                case 109:
                    return Habbo.Respect;
                case 122:
                    return Habbo.IceTagPerks;
                case 125:
                    return Habbo.FurniCount;
                case 126:
                    return Habbo.FurniCountUnsigned;
                case 127:
                    return Habbo.TimeInRoom;
            }

            return 0;
        }

        internal string GenerateBadgeCode(Achievement Achievement, int Level)
        {
            return (string)(Achievement.BadgeCode + Level);
        }

        internal Achievement GetAchievement(uint Id)
        {
            try { return Achievements[Id]; }
            catch { return null; }
        }

        internal AchievementType GetType(int e)
        {
            switch (e)
            {
                case 0: return AchievementType.Social;
                case 1: return AchievementType.Identity;
                case 2: return AchievementType.Games;
                case 3: return AchievementType.Room_Builder;
                case 4: return AchievementType.Explore;
                case 5: return AchievementType.Pets;
                case 6: return AchievementType.Music;
                case 7: return AchievementType.BattleBall;
                case 8: return AchievementType.Freeze;
            }

            return AchievementType.Social;
        }
    }
}