using UnityEngine;
using Unity.GraphToolkit.Editor;
using System;
using Dialogue;

namespace Editor.Dialogue
{
    [Serializable]
    public class StartNode : Node
    {
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddOutputPort("out").Build();
            
            context.AddInputPort<string>("SpeakerName").Build();
        }
    }
    
    [Serializable]
    public class EndNode : Node
    {
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort("in").Build();
        }
    }
    
    [Serializable]
    public enum DialogueType
    {
        SayOneLine,
        SayMultipleLines
    }
    
    [Serializable]
    public class DialogueNode : Node 
    {
        const string LineTypeOptionName = "DialogueLineType";
        const string NoLinesOptionName = "NoLines";
        const string LoopThroughDefaultLinesOptionName = "LoopThroughDefaultLines";
        const string DefaultDialogueContentOptionName = "DefaultDialogueContent";
        
        protected override void OnDefineOptions(IOptionDefinitionContext context)
        {
            context.AddOption<DialogueType>(LineTypeOptionName)
                .WithDisplayName("Default Line Type")
                .WithDefaultValue(DialogueType.SayOneLine)
                .Delayed();

            context.AddOption<int>(NoLinesOptionName)
                .WithDisplayName("Number of Default Lines")
                .WithDefaultValue(1)
                .Delayed();
        }

        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort("in").Build();
            context.AddOutputPort("out").Build();
            
            // Get line type and count options
            var lineTypeOption = GetNodeOptionByName(LineTypeOptionName);
            lineTypeOption.TryGetValue<DialogueType>(out var lineType);
            var lineCountOption = GetNodeOptionByName(NoLinesOptionName);
            lineCountOption.TryGetValue<int>(out var lineCount);

            if (lineType == DialogueType.SayMultipleLines)
            {
                for (var i = 0; i < lineCount; i++)
                {
                    context.AddInputPort<DialogueContent>($"{DefaultDialogueContentOptionName}{i + 1}")
                        .WithDisplayName($"Dialogue Content {i + 1}")
                        .Build();
                }
            }
            else
            {
                context.AddInputPort<DialogueContent>($"{DefaultDialogueContentOptionName}")
                    .WithDisplayName("Dialogue Content")
                    .Build();
            }
            
            context.AddInputPort<bool>($"{LoopThroughDefaultLinesOptionName}")
                .WithDisplayName("Loop Through Content?")
                .Build();
        }
    }

    [Serializable]
    public class WaitOnPuzzleStep : DialogueNode
    {
        const string RequiredPuzzleStep = "RequiredPuzzleStep";
        
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<PuzzleStepSO>(RequiredPuzzleStep).WithDisplayName("Required Puzzle Step").Build();
            
            base.OnDefinePorts(context);
        }
    }
    
    [Serializable]
    public class WaitOnPickup : DialogueNode
    {
        const string RequiredPickupsOptionName = "RequiredPickup";
        
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<PickupItemData>(RequiredPickupsOptionName).WithDisplayName("Required Pickup").Build();
            
            base.OnDefinePorts(context);
        }
    }
    
    [Serializable]
    public class WaitOnSlot : DialogueNode
    {
        const string RequiredSlotOptionName = "RequiredSlot";
        const string IncorrectItemLineTypeOptionName = "IncorrectItemDialogueLineType";
        const string IncorrectItemNoLinesOptionName = "IncorrectItemNoLines";
        const string LoopThroughIncorrectItemLinesOptionName = "LoopThroughIncorrectItemLines";
        const string IncorrectItemDialogueContentOptionName = "IncorrectItemDialogueContent";
        
        const string ForbiddenItemLineTypeOptionName = "ForbiddenItemDialogueLineType";
        const string ForbiddenItemNoLinesOptionName = "ForbiddenItemNoLines";
        const string LoopThroughForbiddenItemLinesOptionName = "LoopThroughForbiddenItemLines";
        const string ForbiddenItemDialogueContentOptionName = "ForbiddenItemDialogueContent";
        
        protected override void OnDefineOptions(IOptionDefinitionContext context)
        {
            base.OnDefineOptions(context);
            
            // Incorrect item options
            context.AddOption<DialogueType>(IncorrectItemLineTypeOptionName)
                .WithDisplayName("Incorrect Item Line Type")
                .WithDefaultValue(DialogueType.SayOneLine)
                .Delayed();
                
            context.AddOption<int>(IncorrectItemNoLinesOptionName)
                .WithDisplayName("Number of Incorrect Item Lines")
                .WithDefaultValue(1)
                .Delayed();
        
            // Forbidden item options
            context.AddOption<DialogueType>(ForbiddenItemLineTypeOptionName)
                .WithDisplayName("Forbidden Item Line Type")
                .WithDefaultValue(DialogueType.SayOneLine)
                .Delayed();
                
            context.AddOption<int>(ForbiddenItemNoLinesOptionName)
                .WithDisplayName("Number of Forbidden Item Lines")
                .WithDefaultValue(1)
                .Delayed();
        }
        
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<PickupItemData>(RequiredSlotOptionName).WithDisplayName("Required Slot").Build();
            
            base.OnDefinePorts(context);
            
            // Process Incorrect Item content
            var incorrectItemLineTypeOption = GetNodeOptionByName(IncorrectItemLineTypeOptionName);
            incorrectItemLineTypeOption.TryGetValue<DialogueType>(out var incorrectItemLineType);
            var incorrectItemLineCountOption = GetNodeOptionByName(IncorrectItemNoLinesOptionName);
            incorrectItemLineCountOption.TryGetValue<int>(out var incorrectItemLineCount);

            // Add DialogueContent ports for incorrect item content
            if (incorrectItemLineType == DialogueType.SayMultipleLines)
            {
                for (var i = 0; i < incorrectItemLineCount; i++)
                {
                    context.AddInputPort<DialogueContent>($"{IncorrectItemDialogueContentOptionName}{i + 1}")
                        .WithDisplayName($"Incorrect Item Content {i + 1}")
                        .Build();
                }
            }
            else
            {
                context.AddInputPort<DialogueContent>($"{IncorrectItemDialogueContentOptionName}")
                    .WithDisplayName("Incorrect Item Content")
                    .Build();
            }
            
            context.AddInputPort<bool>($"{LoopThroughIncorrectItemLinesOptionName}")
                .WithDisplayName("Loop Through Incorrect Content?")
                .Build();
            
            // Process Forbidden Item content
            var forbiddenItemLineTypeOption = GetNodeOptionByName(ForbiddenItemLineTypeOptionName);
            forbiddenItemLineTypeOption.TryGetValue<DialogueType>(out var forbiddenItemLineType);
            var forbiddenItemLineCountOption = GetNodeOptionByName(ForbiddenItemNoLinesOptionName);
            forbiddenItemLineCountOption.TryGetValue<int>(out var forbiddenItemLineCount);

            // Add DialogueContent ports for forbidden item content
            if (forbiddenItemLineType == DialogueType.SayMultipleLines)
            {
                for (var i = 0; i < forbiddenItemLineCount; i++)
                {
                    context.AddInputPort<DialogueContent>($"{ForbiddenItemDialogueContentOptionName}{i + 1}")
                        .WithDisplayName($"Forbidden Item Content {i + 1}")
                        .Build();
                }
            }
            else
            {
                context.AddInputPort<DialogueContent>($"{ForbiddenItemDialogueContentOptionName}")
                    .WithDisplayName("Forbidden Item Content")
                    .Build();
            }
            
            context.AddInputPort<bool>($"{LoopThroughForbiddenItemLinesOptionName}")
                .WithDisplayName("Loop Through Forbidden Content?")
                .Build();
        }
    }
    
    [Serializable]
    public class WaitOnCombination : DialogueNode
    {
        const string RequiredResultItemOptionName = "RequiredResultItem";
        
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<PickupItemData>(RequiredResultItemOptionName).WithDisplayName("Required Result Item").Build();
            
            base.OnDefinePorts(context);
        }
    }
}