using System;
using DonkeysAndDroids;
using Godot;
using RobotAndDonkey.Game.Cards;
using RobotAndDonkey.Game.Execution.Results;
using System.Collections.Generic;
using RobotAndDonkey.Game;
using RobotAndDonkey.Game.Pois;

public partial class CoreLoopScreen : Control, IScreen
{
    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        m_DrawGlitch = GetNode<DrawGlitch>("%Draw Glitch");
        m_Improve = GetNode<Improve>("%Improve");
        m_CosmicRays = GetNode<Gamble>("%Cosmic Rays");
        m_BufferOverflow = GetNode<BufferOverflow>("%Buffer Overflow");
        m_ProgramScreen = GetNode<ProgramScreen>("%Program");
        m_BoardNode = GetNode<BoardNode>("%BoardNode");
        m_CurrencyBar = GetNode<CurrencyBar>("%CurrencyBar");
        m_OptionsButton = GetNode<Button>("%OptionsButton");
        m_SeedButton = GetNode<Button>("%SeedButton");
        m_SeedButton.Pressed += OnSeedButtonPressed;
        m_OptionsButton.Pressed += OnOptionsButtonPressed;
    }

    private void OnSeedButtonPressed()
    {
        DisplayServer.ClipboardSet(Main.Instance.StringSeed);
        //Main.Instance.StartCoreLoop(Random.Shared.Next(), EDifficulty.Easy, ERobotType.Vintage);
    }

    public bool TransitionScreen<T>(T newScreen, Tween tween) where T : Control, IScreen
    {
        newScreen.EnableInputs();
        if (m_CurrentScreen == newScreen)
            return false;

        var parent = newScreen.GetParent();
        parent.MoveChild(newScreen, 1);
        var oldControl = (Control)m_CurrentScreen;
        var oldScreen = m_CurrentScreen;
        m_CurrentScreen = newScreen;
        newScreen.Modulate = new(1, 1, 1);
        newScreen.Visible = true;
        newScreen.Activate();
        if (oldScreen == null)
            return true;

        tween.TweenProperty(oldControl, "modulate", new Color(0, 0, 0, 0), 0.25);
        tween.TweenCallback(Callable.From(() =>
        {
            oldScreen.Deactivate();
            oldControl.Visible = false;
            oldControl.Modulate = new(1, 1, 1);
        }));

        return true;
    }

    public void EnableInputs()
    {
        m_SeedButton.Text = Main.Instance.StringSeed;
        m_CurrentScreen?.EnableInputs();
        m_BoardNode.Configure(Main.Instance.CoreLoop.Board);
        m_CurrencyBar.Configure(Main.Instance.CoreLoop, Main.Instance.CoreLoop.ProgramCount, Main.Instance.CoreLoop.Currency, null);
    }

    public void Activate()
    {
    }

    public void Deactivate()
    {
        if (m_CurrentScreen is Control control)
        {
            control.Visible = false;
            control.Modulate = new(1, 1, 1);
            m_CurrentScreen.Deactivate();
            m_CurrentScreen = null;
        }
    }

    public void DisableInputs()
    {
        m_CurrentScreen?.DisableInputs();
    }

    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _Process(double delta)
    {
    }
    
    public override void _UnhandledInput(InputEvent @event)
    {
        if (@event is InputEventMouse mouseEvent)
        {
            var container = GetNode<Control>("%BoardViewPortContainer");
            if (!container.GetGlobalRect().HasPoint(mouseEvent.Position))
                return;

            var viewPort = GetNode<SubViewport>("%BoardViewPort");
            viewPort.PushInput(@event);

            if (viewPort.IsInputHandled())
                GetViewport().SetInputAsHandled();
        }
    }

    private void OnOptionsButtonPressed()
    {
        Main.Instance.OptionsMenu.ShowMenu();
    }

    public override void _UnhandledKeyInput(InputEvent @event)
    {
        if (@event.IsActionPressed("options") && m_CurrentScreen != null)
        {
            Main.Instance.OptionsMenu.ShowMenu();
            GetViewport().SetInputAsHandled();
        }
    }

    public void DrawGlitch(Card card, Tween tween)
    {
        TransitionScreen(m_DrawGlitch, tween);
        m_DrawGlitch.Configure(card, tween);
    }

    public void Improve(Tween tween)
    {
        TransitionScreen(m_Improve, tween);
        m_Improve.Configure(Main.Instance.CoreLoop.Shop, Main.Instance.CoreLoop.PatchDeck, tween);
    }

    public bool HandleResult(Result result, Tween tween)
    {
        if (m_CurrentScreen.HandleResult(result, tween))
            return true;

        switch (result)
        {
            case CellTypeResult cellResult:
            {
                m_BoardNode.Configure(cellResult, tween);
                return true;
            }
            case ModifyCellResult cellResult:
            {
                m_BoardNode.Configure(cellResult, tween);
                return true;
            }
            case PoiResult cellResult:
            {
                m_BoardNode.Configure(cellResult, tween);
                return true;
            }
            case CurrencyResult currencyResult:
            {
                m_CurrencyBar.Configure(Main.Instance.CoreLoop, Main.Instance.CoreLoop.ProgramCount, currencyResult.NewCurrency, tween);
                return true;
            }
            case ProgramResult programResult:
            {
                m_CurrencyBar.Configure(Main.Instance.CoreLoop, programResult.NewProgram, Main.Instance.CoreLoop.Currency, tween);
                return true;
            }
            case ModifyCardResult modifyCardResult:
            {
                m_Improve.Deck.ModifyCard(modifyCardResult.Card, modifyCardResult.Modifier, tween);
                return true;
            }
            case DeckResult deckResult:
            {
                m_Improve.Deck.Configure(deckResult.Deck, tween, false, false);
                return true;
            }
        }

        GD.Print($"Unhandled result {result.GetType().Name} in screen {m_CurrentScreen.GetType().Name}");
        return false;
    }

    public void CosmicRays(List<Card> gambleCards, Tween tween)
    {
        TransitionScreen(m_CosmicRays, tween);
        m_CosmicRays.Configure(gambleCards, tween);
    }

    public void BufferOverflow(Tween tween)
    {
        TransitionScreen(m_BufferOverflow, tween);
        m_BufferOverflow.Configure(tween);
    }

    public void ExecuteProgram(Tween tween)
    {
        var becomeActive = TransitionScreen(m_ProgramScreen, tween);
        m_ProgramScreen.Configure(becomeActive ? tween : null);
    }

    private ProgramScreen m_ProgramScreen;
    private DrawGlitch m_DrawGlitch;
    private Improve m_Improve;
    private IScreen m_CurrentScreen;
    private Gamble m_CosmicRays;
    private BufferOverflow m_BufferOverflow;
    private BoardNode m_BoardNode;
    private CurrencyBar m_CurrencyBar;
    private Button m_SeedButton;
    private Button m_OptionsButton;
}