package me.lethunderhawk.tradeplugin.trade;

import me.lethunderhawk.economy.EconomyModule;
import me.lethunderhawk.main.Main;
import me.lethunderhawk.main.util.ItalicDeco;
import me.lethunderhawk.tradeplugin.TradeModule;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.SkullMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class TradeSession {

    private final Player p1;
    private final Player p2;

    private final List<ItemStack> p1Items = new ArrayList<>();
    private final List<ItemStack> p2Items = new ArrayList<>();
    private static final NamespacedKey FLUX_KEY =
            new NamespacedKey(Main.getInstance(), "flux_item");
    private static final NamespacedKey OWNER_KEY =
            new NamespacedKey(Main.getInstance(), "flux_owner");
    private static final NamespacedKey VALUE_KEY =
            new NamespacedKey(Main.getInstance(), "flux_value");

    private TradeState state = TradeState.WAITING;
    private int p1Flux = 0, p2Flux = 0;

    private final TradeInventory inventory;



    public TradeSession(Player p1, Player p2) {
        this.p1 = p1;
        this.p2 = p2;
        this.inventory = new TradeInventory(this);
        p1.openInventory(inventory.getInventoryFor(p1));
        p2.openInventory(inventory.getInventoryFor(p2));
    }
    /**
     * @return if the player has already accepted
     */
    public boolean accept(Player p) {
        if (p.equals(p1)) {
            if(state == TradeState.ACCEPTED_P1){
                return true;
            }
            state = state == TradeState.ACCEPTED_P2 ? TradeState.COMPLETED : TradeState.ACCEPTED_P1;
            updateInventories();
        } else if(p.equals(p2)){
            if(state == TradeState.ACCEPTED_P2){
                return true;
            }
            state = state == TradeState.ACCEPTED_P1 ? TradeState.COMPLETED : TradeState.ACCEPTED_P2;
            updateInventories();
        }
        return false;
    }

    public void undoAccept(Player p){
        if (p.equals(p1)) {
            state = state == TradeState.ACCEPTED_P1 ? TradeState.WAITING : TradeState.ACCEPTED_P1;
            updateInventories();
        } else if(p.equals(p2)){
            state = state == TradeState.ACCEPTED_P2 ? TradeState.WAITING : TradeState.ACCEPTED_P2;
            updateInventories();
        }
    }

    private void updateInventories() {
        inventory.updateInventory(state);
    }

    public boolean addItem(Player p, ItemStack item) {
        if(item == null) return false;
        if (p.equals(p1)) {
            if(inventory.addItem(p1, item, true)
                    && inventory.addItem(p2, item, false)){
                p1Items.add(item);
                return true;
            }
        } else if(p.equals(p2)){
            if(inventory.addItem(p2, item, true)
                    && inventory.addItem(p1, item, false)){
                p2Items.add(item);
                return true;
            }
        }
        return false;
    }

    public boolean addCosmeticItem(Player p, ItemStack item) {
        if(item == null) return false;
        if (p.equals(p1)) {
            return inventory.addItem(p1, item, true)
                    && inventory.addItem(p2, item, false);
        } else if(p.equals(p2)){
            return inventory.addItem(p2, item, true)
                    && inventory.addItem(p1, item, false);
        }
        return false;
    }

    public void complete() {
        sendTradeCompletedMsg();
        for (ItemStack item : p1Items) {
            if(item != null){
                p2.getInventory().addItem(item);
            }
        }
        for (ItemStack item : p2Items) {
            if(item != null) {
                p1.getInventory().addItem(item);
            }
        }
        transferFlux();
        p1Items.clear();
        p2Items.clear();

    }
    private void sendReceivingMsg(Audience receiver, Component itemName, int amount){
        TradeModule.sendText(receiver, Component.text("+ ", NamedTextColor.GREEN )
                .append(itemName.color(NamedTextColor.GRAY))
                .append(Component.text((amount> 1 ? " x" + amount : ""), NamedTextColor.GRAY)));
    }
    private void sendGivingMsg(Audience receiver, Component itemName, int amount){
        TradeModule.sendText(receiver, Component.text("- ", NamedTextColor.RED )
                .append(itemName.color(NamedTextColor.GRAY))
                .append(Component.text((amount> 1 ? " x" + amount : ""), NamedTextColor.GRAY)));
    }

    private void sendTradeCompletedMsg() {
        sendTradeCompletedLine(p1, p2);
        sendTradeCompletedLine(p2, p1);

        sendItemTransfers(p1Items, p1, p2);
        sendItemTransfers(p2Items, p2, p1);

        sendFluxTransfer(p1Flux, p1, p2);
        sendFluxTransfer(p2Flux, p2, p1);
    }

    private void sendTradeCompletedLine(Player receiver, Player other) {
        TradeModule.sendText(receiver,
                Component.text("Handel mit ", NamedTextColor.GOLD)
                        .append(other.displayName().color(NamedTextColor.GRAY))
                        .append(Component.text(" abgeschlossen!", NamedTextColor.GOLD))
        );
    }

    private void sendItemTransfers(List<ItemStack> items, Audience giver, Audience receiver) {
        for (ItemStack item : items) {
            if (item == null) continue;
            sendGivingMsg(giver, item.displayName(), item.getAmount());
            sendReceivingMsg(receiver, item.displayName(), item.getAmount());
        }
    }

    private void sendFluxTransfer(int flux, Audience giver, Audience receiver) {
        if (flux <= 0) return;

        Component fluxComp = Component.text(flux)
                .append(Component.text(" Flux"));

        sendGivingMsg(giver, fluxComp, 1);
        sendReceivingMsg(receiver, fluxComp, 1);
    }

    private void transferFlux() {
        if(p2Flux > 0){
            EconomyModule.getInstance().getEconomyAPI().pay(p2.getUniqueId(), p1.getUniqueId(), p2Flux);
        }
        if(p1Flux > 0){
            EconomyModule.getInstance().getEconomyAPI().pay(p1.getUniqueId(), p2.getUniqueId(), p1Flux);
        }
    }

    public void decline() {
        for (ItemStack item : p1Items) {
            if(item != null){
                p1.getInventory().addItem(item);
            }
        }
        for (ItemStack item : p2Items) {
            if(item != null) {
                p2.getInventory().addItem(item);
            }
        }
        p1Items.clear();
        p2Items.clear();
    }

    public Player getP1() { return p1; }
    public Player getP2() { return p2; }

    public TradeInventory getTradeInventory() { return inventory; }

    public TradeState getTradeState() {
        return state;
    }

    public void removeItem(Player p, ItemStack item, int mySlot) {
        if(item == null) return;
        if (p.equals(p1)) {
            if(inventory.removeItem(p1, item, mySlot)){
                p1Items.remove(item);
            }
        } else if(p.equals(p2)){
            if(inventory.removeItem(p2, item, mySlot)){
                p2Items.remove(item);
            }
        }
    }

    public void setTradeState(TradeState state) {
        this.state = state;
    }

    public int getMoneyFor(Player p) {
        if(p1.getUniqueId().equals(p.getUniqueId())){
            return p1Flux;
        }
        if(p2.getUniqueId().equals(p.getUniqueId())){
          return p2Flux;
        }
        return 0;
    }

    public boolean addFluxValue(Player player, int value) {

        if(p1.getUniqueId().equals(player.getUniqueId())){

            if(addCosmeticItem(p1, getCosmeticFlux(p1, value))){
                p1Flux += value;
                refreshAllFlux();
                return true;
            }

        }else if(p2.getUniqueId().equals(player.getUniqueId())){
            if(addCosmeticItem(p2, getCosmeticFlux(p2, value))){
                p2Flux += value;
                refreshAllFlux();
                return true;
            }
        }
        return false;
    }


    public ItemStack getCosmeticFlux(Player owner, int value) {
        ItemStack item = TradeInventory.getFluxItemStack();
        SkullMeta meta = (SkullMeta) item.getItemMeta();

        meta.displayName(ItalicDeco.remove(Component.text(value + " Flux", NamedTextColor.GOLD)));

        meta.getPersistentDataContainer().set(FLUX_KEY, PersistentDataType.INTEGER, 1);
        meta.getPersistentDataContainer().set(OWNER_KEY, PersistentDataType.STRING, owner.getUniqueId().toString());
        meta.getPersistentDataContainer().set(VALUE_KEY, PersistentDataType.INTEGER, value);

        int total = TradeModule.getTradeManager()
                .getSession(owner)
                .getMoneyFor(owner);

        meta.lore(List.of(
                ItalicDeco.remove(Component.text("Lup-sum amount", NamedTextColor.GRAY)),
                ItalicDeco.remove(Component.text("", NamedTextColor.GRAY)),
                ItalicDeco.remove(Component.text("Total Flux Offered: ", NamedTextColor.GOLD)),
                ItalicDeco.remove(Component.text(String.valueOf(total), NamedTextColor.GRAY))
        ));

        item.setItemMeta(meta);
        return item;
    }

    public void refreshFluxItems(Inventory inv) {
        for (int i = 0; i < inv.getSize(); i++) {
            ItemStack item = inv.getItem(i);
            if (item == null) continue;

            ItemMeta meta = item.getItemMeta();
            if (meta == null) continue;

            PersistentDataContainer pdc = meta.getPersistentDataContainer();
            if (!pdc.has(FLUX_KEY, PersistentDataType.INTEGER)) continue;

            UUID ownerId = UUID.fromString(pdc.get(OWNER_KEY, PersistentDataType.STRING));
            int value = pdc.get(VALUE_KEY, PersistentDataType.INTEGER);

            Player owner = ownerId.equals(getP1().getUniqueId())
                    ? getP1()
                    : getP2();

            inv.setItem(i, getCosmeticFlux(owner, value));
        }
    }

    /**
     *
     * @param p The Player who is not the viewer
     * @return The Player who is the viewer
     */
    public Player getViewer(Player p){
        if(p.equals(p1)) {
            return p2;
        }else if(p.equals(p2)) {
            return p1;
        }
        return null;
    }
    public static NamespacedKey getFluxKey(){
        return FLUX_KEY;
    }
    public static NamespacedKey getOwnerKey(){
        return OWNER_KEY;
    }
    public static NamespacedKey getValueKey(){
        return VALUE_KEY;
    }

    public void removeFlux(Player p, int value) {
        if (p.equals(p1)) {
            p1Flux -= value;
            if (p1Flux < 0) p1Flux = 0;
        } else if (p.equals(p2)) {
            p2Flux -= value;
            if (p2Flux < 0) p2Flux = 0;
        }
    }
    public void refreshAllFlux() {
        refreshFluxItems(inventory.getInventoryFor(p1));
        refreshFluxItems(inventory.getInventoryFor(p2));
    }

    public boolean isP1(Player p) {
        return p1.equals(p);
    }
}