using GrandTheftMultiplayer.Server.API;
using GrandTheftMultiplayer.Server.Constant;
using GrandTheftMultiplayer.Server.Elements;
using GrandTheftMultiplayer.Shared;
using GrandTheftMultiplayer.Shared.Math;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using DesignatedLife;

// ReSharper disable UseObjectOrCollectionInitializer

public class Garages : Script
{
    // private Client _player = null;

    public Garages() {  }

    public Garages(Client player)
    {
        // _player = player;
        API.onClientEventTrigger += GarageHandler;
    }

    private List<Garage> _garageList;

    public void Load()
    {
        _garageList = new List<Garage>();
        var db = new GtavEntities();
        var rows = db.garages.Where(v => v.active);

        foreach (var garage in rows)
        {
            var position = new Vector3().fromJson(garage.point_coord);
            var exitPosition = new Vector3().fromJson(garage.exit_coord);
            var heading = (garage.exit_heading);
            var license = "";

            if (garage.license != null)
                license = garage.license;

            _garageList.Add(new Garage(garage.garage_id, position, exitPosition, garage.exit_heading, garage.exit_heading, garage.type, garage.visible, license));
        }

        foreach (var garage in _garageList)
        {
            if (garage.Type == "Car") {
                var CarGaragePed = API.createPed(PedHash.JewelSec01, new Vector3(garage.Position.X, garage.Position.Y, garage.Position.Z), garage.Exit_heading, 0);
            // API.setEntityData(GaragePed, "Garage", true);
                API.setEntityData(CarGaragePed, "GaragePoint", true);
                CarGaragePed.setData("GARAGE_ID", garage.ID);
                CarGaragePed.setData("LICENSE", garage.License);
        }
            if (garage.Type == "Air")
            {
                var AirGaragePed = API.createPed(PedHash.Pilot01SMM, new Vector3(garage.Position.X, garage.Position.Y, garage.Position.Z), garage.Exit_heading, 0);
                API.setEntityData(AirGaragePed, "GaragePoint", true);
                AirGaragePed.setData("GARAGE_ID", garage.ID);
                AirGaragePed.setData("LICENSE", garage.License);
            }
            if (garage.Type == "Car")
            {
                var BoatGaragePed = API.createPed(PedHash.BoatStaff01F, new Vector3(garage.Position.X, garage.Position.Y, garage.Position.Z), garage.Exit_heading, 0);
                API.setEntityData(BoatGaragePed, "GaragePoint", true);
                BoatGaragePed.setData("GARAGE_ID", garage.ID);
                BoatGaragePed.setData("LICENSE", garage.License);
            }


            if (garage.IsVisible) {
                if (garage.Type == "Car")
                    new BlipManager().CreateBlip(garage.Position, 473, 38, "Garage");
                else if (garage.Type == "Air")
                    new BlipManager().CreateBlip(garage.Position, 359, 46, "Garage - Flugzeuge");
                else if (garage.Type == "Ship")
                    new BlipManager().CreateBlip(garage.Position, 356, 84, "Garage - Boote");
            }
        }
    }


    #region ColshapeHandlers

    private void GeneralGarageHandler(Client player, String type)
    {

        if (player == null) return;
        if (MenuManager.HasOpenMenu(player))
            MenuManager.CloseMenu(player);
        if (type == "GaragePoint")
        {
            CreateGarageMenu(player);
            return;
        }
        else
        {
            player.sendNotification("Fehler", "Es ist ein Fehler aufgetreten.", true);
        }
    }

    private void GarageHandler(Client player, string eventName, params object[] arguments)
    {
        if (player == null) return;
        GeneralGarageHandler(player, "GaragePoint");
    }

    private void OnGarageExitHandler(Client player, String type)
    {
        if (player == null) return;
        // GeneralServiceHandler(player, "ACLSServicePoint");

        MenuManager.CloseMenu(player);
		API.resetEntityData(player, "GARAGE_ID");
		API.resetEntityData(player, "GARAGE_POS");
		API.resetEntityData(player, "GARAGE_TYPE");
		API.resetEntityData(player, "GARAGE_EXIT_CORD");
		API.resetEntityData(player, "GARAGE_EXIT_HEAD");
	}

    /*
    private void OnEntityGarageHandler(Client player, String type)
    {
        if (player == null) return;

        string license = API.getEntityData(player, "LICENSE");
        if (license != "" && !Licenses.HasLicense(player, license))
        {
            API.sendNotificationToPlayer(player, "Du hast keine Rechte um auf diese Garage zuzugreifen.", true);
            return;
        }

        if (API.isPlayerInAnyVehicle(player) && PlayerVehicle.HasVehicleKey(API.getPlayerVehicle(player), player))
        {
            API.sendNotificationToPlayer(player, "Du musst aussteigen, um dein Fahrzeug einzuparken.", true);
            return;
        }

        if (!API.isPlayerInAnyVehicle(player))
        {
            CreateGarageMenu(player, API.getEntityData(player, "GARAGE_ID"));
        }
    }
    */
    #endregion


    #region Menu

    public void GarageMenu(Client player)
    {
        if (player == null) return;
        string license = API.getEntityData(player, "LICENSE");
        if (license != "" && !Licenses.HasLicense(player, license))
        {
            GarageHandler(player, "GaragePoint");
            return;
        }
        else
        {
            player.sendNotification("Kein Zugriff!", "Du hast keine Berechtigung für diese Garage.", true);
            return;
        }
    }
    private void CreateGarageMenu(Client player)
    {

        if (MenuManager.HasOpenMenu(player)) MenuManager.CloseMenu(player);

        var menu = new Menu("MainMenu", "Garage", "Mögliche Optionen:", 0, 0, Menu.MenuAnchor.MiddleRight, false, true, false);
        menu.BannerColor = new Color(0, 175, 175, 64);
        menu.Callback = GarageMenuManager;


        var db = new GtavEntities();
        var id = 0;
        var garage = db.garages.FirstOrDefault(g => g.garage_id == id);

        API.setEntityData(player, "GARAGE_ID", id);
        API.setEntityData(player, "GARAGE_POS", garage.point_coord);
		API.setEntityData(player, "GARAGE_TYPE", garage.type);

		List<String> CoordsPos = new List<String>();
		List<int> CoordsHead = new List<int>();
		var garageExits = db.garage_exitcoords.Where(ge => ge.garage_id == id && ge.active == true);
		foreach (var exitCoord in garageExits)
		{
			CoordsPos.Add(exitCoord.exit_coord.ToString());
			CoordsHead.Add(exitCoord.exit_heading);
		}

		API.setEntityData(player, "GARAGE_EXIT_CORD", CoordsPos);
		API.setEntityData(player, "GARAGE_EXIT_HEAD", CoordsHead);

		var menupoint = new MenuItem("Einparken", "", "parkIn");
        menupoint.RightLabel = ">";
        menupoint.ExecuteCallback = true;
        menu.Add(menupoint);

        menupoint = new MenuItem("Ausparken", "", "parkOut");
        menupoint.RightLabel = "<";
        menupoint.ExecuteCallback = true;
        menu.Add(menupoint);

        MenuManager.OpenMenu(player, menu);
    }

    private void CreateParkInMenu(Client player)
    {
        if (MenuManager.HasOpenMenu(player)) MenuManager.CloseMenu(player);

        var menu = new Menu("ParkInMenu", "Garage", "Welches Fahrzeug einparken?", 0, 0, Menu.MenuAnchor.MiddleRight, false, true, false);
        menu.BannerColor = new Color(0, 175, 175, 64);
        menu.Callback = GarageMenuManager;

        var count = 0;
        foreach (var vehicle in API.getAllVehicles())
        {
            if (!(API.getEntityPosition(vehicle).DistanceTo(player.position) < 20)) continue;
            if (!PlayerVehicle.HasVehicleKey(vehicle, player)) continue;

            var vehicleId = vehicle.Value.ToString();
            string vName = API.getEntityData(vehicle, "DISPLAY_NAME");
            var menupoint = new MenuItem(vName, "", vehicleId);
            menupoint.ExecuteCallback = true;
            menu.Add(menupoint);
            count++;
        }

        if (count <= 0)
        {
            API.sendNotificationToPlayer(player, "Keine Fahrzeuge in der Nähe zum Einparken!", true);
            return;
        }

        MenuManager.OpenMenu(player, menu);
    }

    public void CreateParkOutMenu(Client player)
    {
        if (MenuManager.HasOpenMenu(player)) MenuManager.CloseMenu(player);

        var menu = new Menu("ParkOutMenu", "Garage", "Welches Fahrzeug ausparken?", 0, 0, Menu.MenuAnchor.MiddleRight, false, true, false);
        menu.BannerColor = new Color(0, 175, 175, 64);
        menu.Callback = GarageMenuManager;

        int garageId = API.getEntityData(player, "GARAGE_ID");
        string type = API.getEntityData(player, "GARAGE_TYPE");
        var userId = Player.GetUserID(player);

        var db = new GtavEntities();
        var rows = db.vehicles.Where(v => v.user_id == userId && v.type == type && (v.garage == garageId || v.garage == 0) && v.active == 0 && v.impound == 0);

        if (!rows.Any())
        {
            API.sendPictureNotificationToPlayer(player, "Du besitzt aktuell keine Fahrzeuge zum Ausparken.", "CHAR_BLANK_ENTRY", 0, 0, "~g~Garage", "");
            return;
        }

        if (rows.Count() > 10) menu.FastChangeIndex = true;
        foreach (var row in rows)
        {
            var description = "";
            if (row.repair_state != null && row.fuel_current != null)
            {
                var repairState    = ((int)Math.Round((double)(100 * row.repair_state) / 1000)).ToString();
                var fuelState = Convert.ToInt32(row.fuel_current).ToString() + " / " + Convert.ToInt32(row.fuel_max);
                description = "Zustand: " + repairState + "% \nTank: " + fuelState + "l";
            }
            var licPlate = row.license;
            var menupoint = new MenuItem(row.name, description, row.vehicle_id.ToString());
            menupoint.ExecuteCallback = true;
            menupoint.RightLabel = licPlate;
            menu.Add(menupoint);
        }

        MenuManager.OpenMenu(player, menu);

    }

    #endregion


    #region Function

    private void ParkoutVehicle(Client player, string vehicleId)
    {
        var userId = Player.GetUserID(player);
		var count = 0;
		var rangeCheck = 2;

		var db1 = new GtavEntities();

		int garageId = API.getEntityData(player, "GARAGE_ID");

		List<String> garageExitCoords = API.getEntityData(player, "GARAGE_EXIT_CORD");
		List<int> garageExitHeading = API.getEntityData(player, "GARAGE_EXIT_HEAD");
		var garageExitsCounts = garageExitCoords.Count;

		var vId = Convert.ToInt32(vehicleId);
		var vehicleClassdb = db1.vehicles.First(v => v.vehicle_id == vId);

		foreach (var exitCoord in garageExitCoords)
		{
			var garagePosition = new Vector3().fromJson(exitCoord.ToString());
			var garageHeading = Convert.ToInt32(garageExitHeading[count]);

			count++;

			var vehicleClass = API.getVehicleClass(API.vehicleNameToModel(vehicleClassdb.hash));
			if (vehicleClass == 20)
			{
				garageExitsCounts = 1;
				rangeCheck = 6;
			}

			var allVehicles = API.getAllVehicles();
			if (allVehicles.Any(allVehicle => API.getEntityPosition(allVehicle).DistanceTo(garagePosition) < rangeCheck))
			{
				if (garageExitsCounts == count)
				{
					API.sendNotificationToPlayer(player, "Es ist kein Ausparkpunkt frei!", true);
					return;
				}
				continue;
			}

			var db = new GtavEntities();
			db.vehicles.Where(v => v.vehicle_id == vId).Where(v => v.user_id == userId).ToList().ForEach(v => { v.active = 1; v.garage = 0; });
			if (db.SaveChanges() <= 0)
			{
				API.sendPictureNotificationToPlayer(player, "Es ist ein Fehler aufgetreten.", "CHAR_BLANK_ENTRY", 0, 0, "~g~Garage", "");
				return;
			}

			var vehicleMods = new List<string>();
			var neonColor = "";
			var rows = db.vehicle_mods.Where(v => v.vehicle_id == vId).OrderByDescending(v => v.mod_type).Select(v => new { v.mod_type, v.mod });
			foreach (var row in rows)
			{
				if (row.mod_type == 88)
					neonColor = row.mod;
				else
					vehicleMods.Add(API.toJson(new VehicleMod(row.mod_type.ToString(), row.mod)));
			}

			var garageVehicle = db.vehicles.FirstOrDefault(v => v.vehicle_id == vId);
			// ReSharper disable once PossibleNullReferenceException
			var trunk = JsonConvert.DeserializeObject<List<string>>(garageVehicle.trunk);

			var vehicle = new PlayerVehicle().Create(
				API.getHashKey(garageVehicle.hash),
				garagePosition,
				new Vector3(0, 0, garageHeading),
				garageVehicle.color1,
				garageVehicle.color2,
				userId,
				API.getPlayerName(player),
				trunk,
				garageVehicle.weight,
				Convert.ToInt32(garageVehicle.fuel_current),
				Convert.ToInt32(garageVehicle.fuel_max),
				garageVehicle.fuel_type,
				garageVehicle.license,
				garageVehicle.vehicle_id.ToString(),
				vehicleMods,
				Convert.ToInt32(garageVehicle.repair_state),
				Convert.ToInt32(garageVehicle.driven),
				garageVehicle.buy_date.ToString(),
				neonColor
			);

			API.sendPictureNotificationToPlayer(player, "Das Fahrzeug wurde erfolgreich ausgeparkt.", "CHAR_BLANK_ENTRY", 0, 0, "~g~Garage", "");
			if (API.hasEntityData(player, "GARAGE_SIT_IN") && API.getEntityData(player, "GARAGE_SIT_IN") == "1")
			{
				API.resetEntityData(player, "GARAGE_SIT_IN");
				DimensionManager.JoinDimension(player, 0);
				API.setPlayerIntoVehicle(player, vehicle, -1);
				API.resetEntityData(player, "HOUSE_USING_ID");
			}
			API.sendNativeToAllPlayers(0x75DBEC174AEEAD10, vehicle, true);
			return;
		}
    }

    private void ParkVehicle(Client player, string vehicleId)
    {
        var vehicle = new NetHandle(Convert.ToInt32(vehicleId));
        API.setEntityData(vehicle, "GARAGE_ID", API.getEntityData(player, "GARAGE_ID"));
        PlayerVehicle.ParkVehicle(player, vehicle);
    }

    #endregion


    #region MenuHandler

    private void GarageMenuManager(Client player, Menu menu, MenuItem menuItem, int itemIndex, bool forced, dynamic data)
    {
        switch (menu.Id)
        {
            case "MainMenu":
                switch (menuItem.Id)
                {
                    case "parkIn":
                        MenuManager.CloseMenu(player);
                        CreateParkInMenu(player);
                        break;
                    case "parkOut":
                        MenuManager.CloseMenu(player);
                        CreateParkOutMenu(player);
                        break;
                    default:
                        MenuManager.CloseMenu(player);
                        break;
                }
                break;

            case "ParkInMenu":
                switch (menuItem.Id)
                {
                    case "close":
                        MenuManager.CloseMenu(player);
                        break;
                    default:
                        MenuManager.CloseMenu(player);
                        ParkVehicle(player, menuItem.Id);
                        break;
                }
                break;

            case "ParkOutMenu":
                switch (menuItem.Id)
                {
                    case "close":
                        MenuManager.CloseMenu(player);
                        break;
                    default:
                        MenuManager.CloseMenu(player);
                        ParkoutVehicle(player, menuItem.Id);
                        break;
                }
                break;

             default:
                 MenuManager.CloseMenu(player);
                 break;
        }
    }

    #endregion
}