using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Timers;
using GTANetworkAPI;
using Newtonsoft.Json;
using ReallifeGamemode.Server.Entities;
using ReallifeGamemode.Server.Extensions;
using ReallifeGamemode.Server.Models;
using ReallifeGamemode.Server.Services;
using ReallifeGamemode.Server.Util;

namespace ReallifeGamemode.Server.Managers
{
  class ManagerOfInventory : Script
  {
    private static Dictionary<int, (int[],int[])> TradeItems { get; set; } = new Dictionary<int, (int[], int[])>();
    private static Dictionary<int, Timer> TradeTimer { get; set; } = new Dictionary<int,Timer>(); 
    private static Dictionary<int, int> TradeValue { get; set; } = new Dictionary<int, int>();

    public static void GetUserItems(Client client)
    {
      User user = client.GetUser();

      List<int> ItemId = new List<int>();
      List<int> amount = new List<int>();
      List<int> vehItemId = new List<int>();
      List<int> vehAmount = new List<int>();
      using (var context = new DatabaseContext())
      {
        List<UserItem> userItems = context.UserItems.ToList().FindAll(i => i.UserId == user.Id);
        foreach (var item in userItems)
        {
          ItemId.Add(item.ItemId);
          amount.Add(item.Amount);
        }
        foreach(Vehicle veh in NAPI.Pools.GetAllVehicles())
        {
          if(veh.Position.DistanceTo(client.Position) < 1)
          {           
            if (VehicleStreaming.GetDoorState(veh, DoorID.DoorTrunk) == DoorState.DoorOpen)
            {
              ServerVehicle serverVehicle = VehicleManager.GetServerVehicleFromVehicle(veh, context);
              List<VehicleItem> vehicleItems = context.VehicleItems.ToList().FindAll(i => i.VehicleId == serverVehicle.Id);
              foreach (var vehItem in vehicleItems)
              {
                vehItemId.Add(vehItem.ItemId);
                vehAmount.Add(vehItem.Amount);
              }
              client.TriggerEvent("vehInventoryShow", ItemId.ToArray(), amount.ToArray(), vehItemId.ToArray(), vehAmount.ToArray(), serverVehicle.Id);
              return;
            }
            ChatService.SendMessage(client, "Kofferraum ist zu nigger!");
            break;
          }
        }
        client.TriggerEvent("inventoryShow", ItemId.ToArray(), amount.ToArray());
      }
    }

    [RemoteEvent("invUseItem")]
    public void ServerEvent_invUseItem(Client client, int itemId)
    {
      User user = client.GetUser();

      using (var context = new DatabaseContext())
      {
        UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
        if (item.Amount > 1)
        {
          item.Amount -= 1;
        }
        else
        {
          context.UserItems.Remove(item);
        }
        client.SendNotification("Du hast ~g~" + item.Amount + " ~y~" + InventoryManager.GetItemById(itemId).Name + " ~s~ benutzt.", false);
       
        context.SaveChanges();
        return;
      }
    }
    [RemoteEvent("saveHelper")]
    public void ServerEvent_invSaveHelper(Client client, string vehID)
    {
      User user = client.GetUser();
      int serVehID = JsonConvert.DeserializeObject<int>(vehID);


    }


    [RemoteEvent("saveItems")]
    public void ServerEvent_invSaveItems(Client client, string itemIdArr, string itemAmountArr, string SlotArr)
    {
      User user = client.GetUser();

      int itemId = JsonConvert.DeserializeObject<int>(itemIdArr);
      int itemAmount = JsonConvert.DeserializeObject<int>(itemAmountArr);
      int Slot = JsonConvert.DeserializeObject<int>(SlotArr);

      using (var context = new DatabaseContext())
      {
        if (Slot < 24)
        {
          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
          if (item != null)
          {
            item.Amount += itemAmount;
          }
          else
          {
            var newItem = new UserItem
            {
              ItemId = itemId,
              UserId = user.Id,
              Amount = itemAmount,
              Slot = -1
            };

            context.UserItems.Add(newItem);
          }

          context.SaveChanges();
        }
        else
        {
          foreach (Vehicle veh in NAPI.Pools.GetAllVehicles())
          {
            if (veh.Position.DistanceTo(client.Position) < 1)
            {
              if (VehicleStreaming.GetDoorState(veh, DoorID.DoorTrunk) == DoorState.DoorOpen)
              {
                ServerVehicle serverVehicle = VehicleManager.GetServerVehicleFromVehicle(veh, context);
                VehicleItem vehItem = context.VehicleItems.Where(v => v.VehicleId == serverVehicle.Id && v.ItemId == itemId).FirstOrDefault();
                if (vehItem != null)
                {
                  vehItem.Amount = itemAmount;
                }
                else
                {
                  var newItem = new VehicleItem
                  {
                    ItemId = itemId,
                    VehicleId = serverVehicle.Id,
                    Amount = itemAmount,
                    Slot = -1
                  };

                  context.VehicleItems.Add(newItem);
                }
                context.SaveChanges();
              }
            }
          }
        }
      }
    }
    


    [RemoteEvent("invThrowItem")]
    public void ServerEvent_invThrowItem(Client client, int itemId, int amount)
    {
      User user = client.GetUser();

      using (var context = new DatabaseContext())
      {
        UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
        if (item.Amount > amount)
        {
          item.Amount -= amount;
          client.SendNotification("Du hast ~g~" + amount + " ~y~" + InventoryManager.GetItemById(itemId).Name + " ~s~weggeworfen.", false);
        }
        else
        {
          client.SendNotification("Du hast ~g~" + item.Amount + " ~y~" + InventoryManager.GetItemById(itemId).Name + " ~s~weggeworfen.", false);
          context.UserItems.Remove(item);        
        }
        context.SaveChanges();
        return;
      }
    }

    [RemoteEvent("tradeItem")]
    public void ServerEvent_tradeItem(Client client, int value, string nameOrId, string itemIdArrStr, string itemAmountArrStr)
    {
      User user = client.GetUser();
      Client target = ClientService.GetClientByNameOrId(nameOrId);
      if (target == null || !target.IsLoggedIn() || target == client)
      {
        ChatService.PlayerNotFound(client);
        return;
      }
      if(client.Position.DistanceTo(target.Position) >= 5)
      {
        ChatService.ErrorMessage(client, "Spieler ist zu weit entfernt.");
        return;
      }
      int[] itemIdArr = JsonConvert.DeserializeObject<int[]>(itemIdArrStr);
      int[] itemAmountArr = JsonConvert.DeserializeObject<int[]>(itemAmountArrStr);
      
      if (target.HasData("inTrade") && target.GetData("inTrade") == true)
      {
        ChatService.SendMessage(client, $"~r~[FEHLER] ~w~{target.Name} befindet sich bereits in einem Handel.");
        return;
      }
      using (var context = new DatabaseContext())
      {
        for (int x = 0; x < itemIdArr.Length; x++)
        {
          int itemId = itemIdArr[x];
          int itemAmount = itemAmountArr[x];
          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
          if (item.Amount - itemAmount > 0)
          {
            item.Amount -= itemAmount;
          }
          else
          {
            context.UserItems.Remove(item);
          }
          context.SaveChanges();
        }
      }
      ChatService.SendMessage(client, $"~b~Du hast eine Handelsanfrage an {target.Name} gesendet.");
      TradeItems[user.Id] = (itemIdArr, itemAmountArr);
      TradeValue[user.Id] = value;
      target.SetData("tradePartner", user.Id);
      target.SetData("trade", client.Name);
      SendTradeOffer(target,client);
    }

    public void SendTradeOffer(Client client, Client sender)
    {
      client.SetData("inTrade", true);
      sender.SetData("inTrade", true);
      ChatService.SendMessage(client, $"~b~ Du hast eine Handelsanfrage von {sender.Name} bekommen.");
      ChatService.SendMessage(client, $"~b~ Drücke '~w~X~b~' um die Handelsanfrage zu akzeptieren.");
      User user = sender.GetUser();
      Timer tradeTimer = new Timer(30000);
      TradeTimer[user.Id] = tradeTimer;
      tradeTimer.Start();
      tradeTimer.Elapsed += (s, e) => { SendBackToSender(sender); client.SetData("inTrade", false); sender.SetData("inTrade", false); };
    }


    public void SendBackToSender(Client client)
    {
      User user = client.GetUser();
      ChatService.SendMessage(client, "Dein Handelspartner hat die Anfrage nicht angenommen.");
      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[user.Id];
      Timer timer = TradeTimer[user.Id];
      timer.Stop();
      using (var context = new DatabaseContext())
      {
        for (int x = 0; x < itemIdArr.Length; x++)
        {
          int itemId = itemIdArr[x];
          int itemAmount = itemAmountArr[x];
          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
          if (item != null)
          {
            item.Amount += itemAmount;
          }
          else
          {
            var newItem = new UserItem
            {
              ItemId = itemId,
              UserId = user.Id,
              Amount = itemAmount,
              Slot = -1
            };

            context.UserItems.Add(newItem);
          }
          context.SaveChanges();
        }
      }
    }

    [RemoteEvent("declineTrade")]
    public void ServerEvent_declineTrade(Client client)
    {
      if (!client.GetData("inTrade"))
      {
        ChatService.ErrorMessage(client, "Das Handelsangebot ist abgelaufen.");
        return;
      }
      string name = client.GetData("trade");
      Client target = ClientService.GetClientByNameOrId(name);
      if (target == null || !target.IsLoggedIn())
      {
        ChatService.PlayerNotFound(client);
        return;
      }
      client.SetData("inTrade", false);
      target.SetData("inTrade", false);
      SendBackToSender(target);
    }

    public static void OpenTradeAccept(Client client)
    {
      User user = client.GetUser();
      int id = client.GetData("tradePartner");
      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[id];
      Timer tradeTimer = TradeTimer[id];
      tradeTimer.Stop();
      tradeTimer.Start();
      client.TriggerEvent("openTradeWindow", TradeValue[id], itemIdArr, itemAmountArr);
    }

    [RemoteEvent("acceptTrade")]
    public void ServerEvent_AcceptTrade(Client client)
    {
      if (!client.GetData("inTrade"))
      {
        ChatService.ErrorMessage(client, "Das Handelsangebot ist abgelaufen.");
        return;
      }

      client.SetData("inTrade", false);
      
      User user = client.GetUser();
      int id = client.GetData("tradePartner");
      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[id];
      Timer tradeTimer = TradeTimer[id];
      tradeTimer.Stop();
      string name = client.GetData("trade");
      Client target = ClientService.GetClientByNameOrId(name);
      if (target == null || !target.IsLoggedIn())
      {
        ChatService.PlayerNotFound(client);
        return;
      }
      target.SetData("inTrade", false);
      ChatService.SendMessage(target, $"{client.Name} hat deine Anfrage angenommen.");
      using (var context = new DatabaseContext())
      {
        for (int x = 0; x < itemIdArr.Length; x++)
        {
          int itemId = itemIdArr[x];
          int itemAmount = itemAmountArr[x];
          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
          if (item != null)
          {
            item.Amount += itemAmount;
          }
          else
          {
            var newItem = new UserItem
            {
              ItemId = itemId,
              UserId = user.Id,
              Amount = itemAmount,
              Slot = -1
            };

            context.UserItems.Add(newItem);
          }
          context.SaveChanges();
        }
      }
    }
  }
}