using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using GTANetworkAPI;
using reallife_gamemode.Server.Events;
using reallife_gamemode.Server.Extensions;
using reallife_gamemode.Server.Services;
using reallife_gamemode.Server.Util;
using reallife_gamemode.Model;

/**
* @overview Life of German Reallife - Admin Commands (Admin.cs)
* @author VegaZ, hydrant, xSprite
* @copyright (c) 2008 - 2018 Life of German
*/

namespace reallife_gamemode.Server.Commands
{
    public class Admin : Script
    {
        [Command("o", "~m~Benutzung: ~s~/o [Nachricht]", GreedyArg = true)]
        public void CmdAdminO(Client player, string message)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.SUPPORTER) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            string publicMessage = "~b~(( " + player.Name + ": " + message + " ))";
            NAPI.Chat.SendChatMessageToAll(publicMessage);
        }

        [Command("veh", "~m~Benutzung: ~s~/veh [Fahrzeug] (Farbe 1) (Farbe 2)")]
        public void CmdAdminVeh(Client player, VehicleHash hash, int color1 = 111, int color2 = 111)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (player.IsInVehicle) // Man darf keine Autos erstellen, wenn man selbst in einem sitzt (verhindert Bugs)
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Du sitzt momentan schon in einem Fahrzeug.");
                return;
            }

            Vehicle v = NAPI.Vehicle.CreateVehicle(hash, player.Position, player.Rotation.Z, color1, color2);

            player.SetIntoVehicle(v.Handle, -1);
            player.SendChatMessage("Maxspeed: + " +player.Vehicle.MaxSpeed + "");
        }

        [Command("fv")]
        public void CmdAdminFixveh(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (!player.IsInVehicle)
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Du sitzt momentan nicht in einem Fahrzeug.");
                return;
            }

            player.Vehicle.Repair();
        }

        [Command("vdestroy")]
        public void CmdAdminDelveh(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (!player.IsInVehicle) // Man darf keine Autos erstellen, wenn man selbst in einem sitzt (verhindert Bugs)
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Du sitzt momentan nicht in einem Fahrzeug.");
                return;
            }

            /* TODO: Checken, ob das Fahrzeug in einem System genutzt wird (Fraktions-Autos / Spieler-Auto)
             * Wenn Ja: Abbrechen und mitteilen, dass man den System-spezifischen Befehl zu nutzen hat */

            player.Vehicle.Delete();
        }

        [Command("to", "~m~Benutzung: ~s~/to [Name]")]
        public void CmdAdminGoto(Client player, string name)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.SUPPORTER) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            Client target = ClientService.GetClientByName(name);

            if (target == null)
            {
                ChatService.PlayerNotFound(player);
                return;
            }

            player.Position = target.Position;
        }

        [Command("position")]
        public void CmdAdminShowPos(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            player.SendChatMessage("Position: X Y Z: " + player.Position + "");
        }

        [Command("gotox", "~m~Benutzung: ~s~/gotox [X] [Y] [Z]")]
        public void CmdAdminGotoxyz(Client player, float x, float y, float z)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            player.Position = new Vector3(x, y, z);
        }

        [Command("gh", "~m~Benutzung: ~s~/gh [Name]")]
        public void CmdAdminGethere(Client player, string name)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.SUPPORTER) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            Client target = ClientService.GetClientByName(name);

            if (target == null)
            {
                ChatService.PlayerNotFound(player);
                return;
            }

            target.Position = player.Position;
            target.SendChatMessage("Du wurdest von " + player.Name + " teleportiert.");
        }

        [Command("ipl", "~m~Benutzung: ~s~/ipl [Load / Remove] [Name]")]
        public void CmdAdminIpl(Client player, string option, string name)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            option = option.ToLower();

            if (option == "load")
            {
                NAPI.World.RequestIpl(name);
                player.SendChatMessage("~g~Das IPL ~s~" + name + " ~g~wurde erfolgreich geladen");
            }
            else if (option == "remove")
            {
                NAPI.World.RemoveIpl(name);
                player.SendChatMessage("~g~Das IPL ~s~" + name + " ~g~wurde erfolgreich entladen");
            }
            else
            {
                player.SendChatMessage("~m~Benutzung: ~s~/ipl [Load / Remove] [Name]");
            }
        }

        [Command("giveweapon", "~m~Benutzung: ~s~/giveweapon [Spieler] [Waffe] [Munition]")]
        public void CmdAdminGiveweapon(Client player, string name, string weapon, int ammo)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (ammo <= 0)
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Es muss mindestens 1 Munition vergeben werden.");
                return;
            }

            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }

            WeaponHash wHash = NAPI.Util.WeaponNameToModel(weapon);

            if (wHash == default(WeaponHash))
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Diese Waffe existiert nicht.");
                return;
            }

            target.GiveWeapon(wHash, ammo);
            target.SendChatMessage("~b~Du hast von " +player.Name +" eine/n " + wHash + " mit einer Munition von " +ammo + " erhalten.");
            player.SendChatMessage("~b~Du hast " + target.Name + " eine/n " + wHash + " mit einer Munition von " + ammo + " gegeben.");
        }

        [Command("sethp", "~m~Benutzung: ~s~/sethp [Spieler] (Leben)")]
        public void CmdAdminSetHp(Client player, string name, int hp = 100)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }

            target.Health = hp;
            target.SendChatMessage("~b~Dein Leben wurde von " + player.Name + " auf " + hp + " gesetzt.");
            player.SendChatMessage("~b~Du hast das Leben von " + target.Name + " auf " + hp + " gesetzt.");
        }

        [Command("setarmor", "~m~Benutzung: ~s~/setarmor [Spieler] (Armor)")]
        public void CmdAdminSetArmor(Client player, string name, int armor = 100)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }

            target.Armor = armor;
            target.SendChatMessage("~b~Deine Rüstung wurde von " + player.Name + " auf " + armor + " gesetzt.");
            player.SendChatMessage("~b~Du hast die Rüstung von " + target.Name + " auf " + armor + " gesetzt.");
        }

        [Command("setskin", "~m~Benutzung: ~s~/setskin [Spieler] [Skin]")]
        public void CmdAdminSetSkin(Client player, string name, string Skin)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }

            var skin = NAPI.Util.PedNameToModel(Skin);
            target.SendChatMessage("~b~Dein Skin wurde von " + player.Name + " zu " + skin + " gesetzt.");
            player.SendChatMessage("~b~Du hast den Skin von " + target.Name + " zu " + skin + " gesetzt.");
            target.SetSkin(NAPI.Util.PedNameToModel(Skin));
        }

        [Command("vcolor", "~m~Benutzung: ~s~/vcolor [Farb-ID1] [Farb-ID2]")]
        public void CmdAdminColor(Client player, int color1, int color2)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (!player.IsInVehicle)
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Du sitzt momentan in keinem Fahrzeug!");
                return;
            }

            player.Vehicle.PrimaryColor = color1;
            player.Vehicle.SecondaryColor = color2;
            player.SendChatMessage("Farb-ID1 " + color1 + ", Farb-ID2 " + color2 + "");
        }

        [Command("aw", "~m~Benutzung: ~s~/aw [Spieler] [Nachricht]")]
        public void CmdAdminMsg(Client player, string name, string msg)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }
            if (target == player)
            {
                ChatService.ErrorMsg(player);
                return;
            }
            target.SendChatMessage("~y~PM von "+ player.Name + ": " + msg +" ");
            player.SendChatMessage("~y~PM an "+ target.Name + ": " + msg + " ");
        }

        [Command("takeweapon", "~m~Benutzung: ~s~/takeweapon [Spieler]")]
        public void CmdAdminTakeWeapon(Client player, string name)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            Client target = ClientService.GetClientByName(name);
            if (target == null)
            {
                ChatService.PlayerNotFound(target);
                return;
            }
            player.RemoveAllWeapons();
            target.SendChatMessage("~b~Deine Waffen wurden dir von " + player.Name + "(Admin) abgenommen");
            player.SendChatMessage("~b~Dem Spieler " + target.Name + " wurden erfolgreich alle Waffen abgenommen ");
        }

        [Command("rsethp", "~m~Benutzung: ~s~/rsethp [Radius] (Leben)")]
        public void CmdAdminRangeSetHP(Client player, float radius, int hp = 100)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            var peopleInRange = NAPI.Player.GetPlayersInRadiusOfPlayer(radius, player);

            foreach (var managedClient in peopleInRange)
            {
                managedClient.Health = hp;
                managedClient.SendChatMessage("~b~Admin "+ player.Name + " hat im Radius von " + radius + " die HP auf " + hp + " gesetzt.");
            }
            player.SendChatMessage("~b~Das Leben von " + peopleInRange.Count + " Spielern wurde auf "+ hp + " gesetzt.");
        }

        [Command("rsetarmor", "~m~Benutzung: ~s~/rsetarmor [Radius] (Armor)")]
        public void CmdAdminRangeSetArmor(Client player, float radius, int Armor = 100)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            var peopleInRange = NAPI.Player.GetPlayersInRadiusOfPlayer(radius, player);

            foreach (var managedClient in peopleInRange)
            {
                managedClient.Health = Armor;
                managedClient.SendChatMessage("~b~Admin " + player.Name + " hat im Radius von " + radius + " die Rüstung auf " + Armor + " gesetzt.");
            }
            player.SendChatMessage("~b~Die Rüstung von " + peopleInRange.Count + " Spielern wurde auf " + Armor + " gesetzt.");
        }

        [Command("time", "~m~Benutzung: ~s~/time [Stunde] (Minuten) (Sekunden)")]
        public void CmdAdminSetTime(Client player, int hour, int min = 0, int sec = 0)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            NAPI.World.SetTime(hour, min, sec);
            NAPI.Chat.SendChatMessageToAll("Serverzeit auf " + hour + ":" + min + ":" + sec + " gestellt");

        }

        [Command("rgiveweapon", "~m~Benutzung: ~s~/rgiveweapon [Radius] [Waffe] [Munition]")]
        public void CmdAdminRangeGiveWeapon(Client player, float radius, string weapon, int munition)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            WeaponHash wHash = NAPI.Util.WeaponNameToModel(weapon);

            if (wHash == default(WeaponHash))
            {
                player.SendChatMessage("~r~[FEHLER]~s~ Diese Waffe existiert nicht.");
                return;
            }

            var peopleInRange = NAPI.Player.GetPlayersInRadiusOfPlayer(radius, player);

            foreach (var managedClient in peopleInRange)
            {
                managedClient.GiveWeapon(wHash, munition);
                managedClient.SendChatMessage("~b~Admin " +player.Name + " hat im Radius von " + radius + " eine/n " + weapon +" mit " + munition +" Munition vergeben.");
            }
            player.SendChatMessage("~b~Du hast " + peopleInRange.Count +" Spielern eine " + weapon + " mit " + munition + " Munition gegeben");
        }

        [Command("save", "~m~Benutzung: ~s~/save [Typ = ~g~Blip, ~r~Marker, Ped, Pickup, TextLabel, ~g~Vehicle")]
        public void CmdAdminSave(Client player, string typ)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.SUPPORTER) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            switch (typ)
            {
                case "Blip":
                    player.TriggerEvent("saveBlip");
                    break;
                case "Vehicle":
                    if (player.IsInVehicle)
                    {
                        Vehicle vehicle = player.Vehicle;
                        SaveData.SaveVehicleData((VehicleHash) vehicle.Model, vehicle.Position, vehicle.Heading, vehicle.NumberPlate,
                            Convert.ToByte(vehicle.PrimaryColor), Convert.ToByte(vehicle.SecondaryColor), vehicle.Locked, vehicle.EngineStatus, Convert.ToByte(vehicle.Dimension));
                    }
                    else player.SendChatMessage("~m~Du sitzt in keinem Fahrzeug!");
                    break;
                
            }
            
        }
        //TEST COMMAND
        [Command("own")]
        public void CmdAdminOwn(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            if (player.IsInVehicle)
            {
                Vehicle playerVehicle = player.Vehicle;
                using (var saveVehicle = new Model.DatabaseContext())
                {
                    var dataSet = new Entities.UserVehicle
                    {
                        UserId = player.GetUser().Id,
                        Model = (VehicleHash) playerVehicle.Model,
                        PositionX = playerVehicle.Position.X,
                        PositionY = playerVehicle.Position.Y,
                        PositionZ = playerVehicle.Position.Z,
                        Heading = playerVehicle.Heading,
                        NumberPlate = playerVehicle.NumberPlate,
                        PrimaryColor = Convert.ToByte(playerVehicle.PrimaryColor),
                        SecondaryColor = Convert.ToByte(playerVehicle.SecondaryColor),
                        Locked = playerVehicle.Locked,
                        Engine = playerVehicle.EngineStatus,
                        Dimension = Convert.ToByte(playerVehicle.Dimension),
                    };
                    saveVehicle.UserVehicles.Add(dataSet);
                    saveVehicle.SaveChanges();
                }

            }
            else player.SendChatMessage("~m~Du sitzt in keinem Fahrzeug!");

        }
        //TEST COMMAND
        [Command("myvehicles")]
        public void CmdAdminMyVehicles(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }
            player.SendChatMessage("Deine Fahrzeuge: ");
            using (var loadData = new DatabaseContext())
            {
                foreach (Entities.UserVehicle v in loadData.UserVehicles)
                {
                    if (v.UserId == ClientExtension.GetUser(player).Id)
                    {
                        player.SendChatMessage("~b~" + NAPI.Vehicle.GetVehicleDisplayName(v.Model));
                    }
                }
            }
        }

        /*
        [Command("restart")]
        public void CmdAdminRestart(Client player)
        {
            if (ClientExtension.IsLoggedIn(player) == false)
            {
                ChatService.PlayerNotLoggedIn(player);
                return;
            }
            if (!player.GetUser()?.IsAdmin(AdminLevel.ADMIN) ?? true)
            {
                ChatService.NotAuthorized(player);
                return;
            }

            var users = NAPI.Pools.GetAllPlayers();

            foreach(Client user in users)
            {
                user.SendChatMessage("~r~Server startet neu.~s~ Bitte verbinde dich über ~y~F1~s~ neu.");
                user.Kick();
            }

            NAPI.Resource.StopResource("reallife-gamemode");
        }*/
    }
}