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

namespace DuckEmulator.HabboHotel.Outside.Quests
{
    class QuestManager
    {
        internal SecurityDictionary<UInt32, QuestCat> QuestCategorys;
        internal SecurityDictionary<UInt32, Quest> Quests;

        /// <summary>
        /// Generates a new QuestManager
        /// </summary>
        internal QuestManager()
        {
            LoadQuestCategorys();
            LoadQuests();
        }

        /// <summary>
        /// Initialize Quest - Categorys [Identity, Daily, Room_builder, Explore, Battleball, Freeze, Social, Pets]
        /// </summary>
        internal void LoadQuestCategorys()
        {
            // Clean the DataLists
            QuestCategorys = new SecurityDictionary<UInt32, QuestCat>();

            DataTable Data = null;

            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.setQuery("SELECT id,type FROM quest_categorys ORDER BY order_num ASC");
                Data = Adapter.getTable();
            }

            if (Data == null)
            {
                return;
            }

            foreach (DataRow Row in Data.Rows)
            {
                QuestCat fCat = new QuestCat(Convert.ToUInt32(Row["id"]), Convert.ToString(Row["type"]));

                QuestCategorys.Add(fCat.Id,fCat);
            }

            DuckEnvironment.WriteLine("Loaded " + QuestCategorys.Count + " Quest category(s).", ConsoleColor.Yellow);
        }

        internal void LoadQuests()
        {
            // Clean the DataLists
            Quests = new SecurityDictionary<UInt32, Quest>();

            DataTable Data = null;

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

            if (Data == null)
            {
                return;
            }

            foreach (DataRow Row in Data.Rows)
            {
                Quest fQuest = new Quest(Convert.ToUInt32(Row["id"]), Convert.ToUInt32(Row["category"]),
                    Convert.ToString(Row["action"]), Convert.ToInt32(Row["amount"]), (QuestReward)Convert.ToInt32(Row["reward"]), Convert.ToInt32(Row["reward_count"]),
                    Convert.ToInt32(Row["level_num"]));

                Quests.Add(fQuest.Id, fQuest);
            }

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

        internal Quest GetQuest(UInt32 Id)
        {
            try { return Quests[Id]; }
            catch { return null; }
        }

        internal QuestCat GetQuestCat(UInt32 Id)
        {
            try { return QuestCategorys[Id]; }
            catch { return null; }
        }

        internal List<Quest> GetQuestsForCat(UInt32 Category)
        {
            var List = new List<Quest>();

            foreach (Quest Quest in Quests.Values.ToList())
            {
                if (Quest.CatId == Category)
                {
                    List.Add(Quest);
                }
            }

            return List.ToList();
        }

        internal List<QuestCat> GetCategorysWithQuests()
        {
            var List = new List<QuestCat>();

            foreach (UInt32 CatId in QuestCategorys.Keys.ToList())
            {
                if (GetQuestsForCat(CatId).Count > 0)
                {
                    List.Add(QuestCategorys[CatId]);
                }
            }

            return List.ToList();
        }

        internal Int32 CompletedQuestCount(UInt32 CatId, HabboData Habbo)
        {
            Int32 Count = new Int32();

            foreach (UInt32 QuestId in Habbo.Quests)
            {
                if (Quests.ContainsKey(QuestId))
                {
                    Quest Quest = Quests[QuestId];

                    if (Quest != null && Quest.CatId == CatId)
                    {
                        Count++;
                    }
                }
            }

            return Count;
        }

        internal ServerMessage Serialize(HabboData Habbo)
        {
            var QuestCats = GetCategorysWithQuests();

            ServerMessage Message = new ServerMessage(800);
            Message.AppendInt32(QuestCats.Count);

            foreach (QuestCat Cat in QuestCats)
            {
                Cat.Serialize(Message, Habbo);
            }

            Message.AppendBoolean(true);

            return Message;
        }

        internal void AcceptNextQuest(HabboData Habbo)
        {
            var Quests = DuckEnvironment.QuestManager.GetQuestsForCat(Habbo.LastQuestCat);
            var CompletedQuestCount = DuckEnvironment.QuestManager.CompletedQuestCount(Habbo.LastQuestCat, Habbo);

            if (CompletedQuestCount >= Quests.Count)
            {
                return;
            }

            var CurrentQuest = Quests[CompletedQuestCount];

            AcceptQuest(CurrentQuest.Id, Habbo);
        }

        internal void UpdateQuest(HabboData Habbo)
        {
            if (Habbo == null)
            {
                return;
            }

            var CurrentQuest = GetQuest(Habbo.ProgressQuest);

            if (CurrentQuest == null)
            {
                return;
            }

            var CurrentQuestCategory = GetQuestCat(CurrentQuest.CatId);

            if (CurrentQuestCategory == null)
            {
                return;
            }

            Habbo.ProgressForQuest++;

            if (Habbo.ProgressForQuest >= CurrentQuest.Amount)
            {
                UnlockQuest(CurrentQuest.Id, Habbo);
            }
            else
            {
                Habbo.UpdateVariable("current_quest_progress", Habbo.ProgressForQuest);
            }

            ServerMessage UpdateMessage = new ServerMessage(802);
            CurrentQuestCategory.Serialize(UpdateMessage, Habbo);
            Habbo.SendResponse(UpdateMessage);
        }

        internal void UnlockQuest(UInt32 Id, HabboData Habbo)
        {
            var SelectedQuest = GetQuest(Id);

            if (SelectedQuest == null)
            {
                return;
            }

            var SelectedCategory = GetQuestCat(SelectedQuest.CatId);

            if (SelectedCategory == null)
            {
                return;
            }

            if (SelectedQuest.Reward == QuestReward.Pixels)
            {
                Habbo.UpdatePixels(SelectedQuest.RewardCount, true);
            }

            ServerMessage UnlockMessage = new ServerMessage(801);
            SelectedCategory.Serialize(UnlockMessage, Habbo);
            Habbo.SendResponse(UnlockMessage);

            Habbo.Quests.Add(Id);

            Habbo.SendResponse(Serialize(Habbo));

            // Querys at least, we're not gonna w8 for servermessage before the query has sended.
            using (IQueryAdapter Adapter = DuckEnvironment.GetAdapter())
            {
                Adapter.runFastQuery("INSERT INTO user_quests (user_id,quest_id) VALUES ('" + Habbo.Id + "','" + Id + "')");
            }

            Habbo.UpdateVariable("current_quest_id", 0);
            Habbo.UpdateVariable("current_quest_progress", 0);
            Habbo.LastQuestCat = SelectedCategory.Id;
        }

        internal ServerMessage SerializeSideBar(UInt32 QuestId, HabboData Habbo)
        {
            var SelectedQuest = GetQuest(QuestId);

            if (SelectedQuest == null)
            {
                return null;
            }

            var SelectedCategory = GetQuestCat(SelectedQuest.CatId);

            if (SelectedCategory == null)
            {
                return null;
            }

            ServerMessage Message = new ServerMessage(802);
            SelectedCategory.Serialize(Message, Habbo);
            return Message;
        }

        internal void AcceptQuest(UInt32 Id, HabboData Habbo)
        {
            if (Habbo.ProgressQuest == Id)
            {
                return;
            }

            if (Habbo.ProgressQuest > 0)
            {
                CancelQuest(Habbo);
            }

            var SelectedQuest = GetQuest(Id);

            if (SelectedQuest == null)
            {
                return;
            }

            var SelectedCategory = GetQuestCat(SelectedQuest.CatId);

            if (SelectedCategory == null)
            {
                return;
            }

            Habbo.ProgressQuest = Id;
            Habbo.ProgressForQuest = 0;

            Habbo.SendResponse(SerializeSideBar(Id, Habbo));

            Habbo.SendResponse(Serialize(Habbo));

            Habbo.UpdateVariable("current_quest_id", Id);
            Habbo.UpdateVariable("current_quest_progress", 0);
        }

        internal void CancelQuest(HabboData Habbo)
        {
            if (Habbo.ProgressQuest <= 0)
            {
                return;
            }

            Habbo.ProgressQuest = 0;
            Habbo.ProgressForQuest = 0;

            // Clear sidebar
            Habbo.SendResponse(new ServerMessage(803));

            Habbo.SendResponse(Serialize(Habbo));

            Habbo.UpdateVariable("current_quest_id", 0);
            Habbo.UpdateVariable("current_quest_progress", 0);
        }
    }
}