Menu.del

import "Trigger.del";

//Menus

public define stringConstants: ["", "\r\n"];

struct SingleHUDMenu : AbstractMenu {

    define HUDOption(ref define index): <"<0><1><2>", currentOptionIndex==index ? IconString(Icon.ArrowRight) : root.stringConstants[0], (options[index] != root.stringConstants[0]) ? options[index].DisplayName:root.stringConstants[0], options[index+1] != null ? root.stringConstants[1] : root.stringConstants[0]>;
    define HUDTextChunk(ref define first = null, ref define second = null, ref define third = null): <"<0><1><2>", first, second, third>;


    define valueCount = 0;

    define optionString;

    public SingleHUDMenu(ref define player){
        subscribedPlayer = player;
        CreateHudText(enabled?subscribedPlayer:null, optionString, null, null, Location.Left, 0, Color.Red, Color.White, Color.White, HudTextRev.VisibleToSortOrderAndString, Spectators.DefaultVisibility);
        UpdateMenu();
    }

    public override void RegisterMenuOption(ref MenuOption option){
        option.index = valueCount;
        options[valueCount] = option;
        valueCount += 1;
        UpdateMenu();
    }


    public override void SetCurrentOptionIndex(ref define index){
        currentOptionIndex = RoundToInteger((Max(Min(CountOf(options), index), -1)), Rounding.Down);
        if(currentOptionIndex <= -1)
            currentOptionIndex = valueCount - 1;
        else if(currentOptionIndex >= valueCount){
            currentOptionIndex = 0;
        }
        UpdateMenu();
    }

    public void UpdateMenu() "[Subroutine] Update Single-HUD Menu"{
        optionString = "";
        for(define i = 0; i < CountOf(options); i++){
            optionString = <"<0><1>", optionString, HUDOption(i)>;
        }
    }

}


struct MultiHUDMenu : AbstractMenu{

    public MultiHUDMenu(ref define player){
        subscribedPlayer = player;
    }

    public override void RegisterMenuOption(ref MenuOption option){
        option.index = CountOf(options);
        options = Append(options, option);
        
        CreateHudText(enabled?subscribedPlayer:null, HUDOption(option), null, null, Location.Left, option.index, Color.Red, Color.White, Color.White, HudTextRev.VisibleToSortOrderAndString, Spectators.DefaultVisibility);

        option.textId = LastTextID();
    }   

    public override void SetCurrentOptionIndex(ref define index){
        currentOptionIndex = RoundToInteger((Max(Min(CountOf(options), index), -1)), Rounding.Down);
        if(currentOptionIndex <= -1)
            currentOptionIndex = CountOf(options) - 1;
        else if(currentOptionIndex >= CountOf(options)){
            currentOptionIndex = 0;
        }

    }

}

struct AbstractMenu {
    public MenuOption[] options = [];

    public AbstractMenuOptionValue CurrentOptionValue: CurrentOption.CurrentValue;
    public MenuOption CurrentOption: options[currentOptionIndex];

    public define currentOptionIndex;

    public define enabled;

    protected define subscribedPlayer;

    define optionStrings = [];

    define HUDOption(ref MenuOption option): <"<0><1>", currentOptionIndex==option.index?IconString(Icon.ArrowRight):"",option.DisplayName>;


    public Menu(ref define player){
        subscribedPlayer = player;
    }

    public virtual void RegisterMenuOption(ref MenuOption option){
    }   

    public virtual void SetCurrentOptionIndex(ref define index){
    }

    public void ModifyCurrentOptionIndex(ref define difference){
        SetCurrentOptionIndex(currentOptionIndex + difference);
    }
}
//End of Menus


//MenuOptions

// enum MenuOptionType {
//     NullMenuOption,
//     Button,
//     Float,
//     List
//}

struct MenuListOption : MenuOption {

    public MenuOptionValue[] values = [];

    public override MenuOptionValue CurrentValue: values[currentValueIndex];
    
    public define currentValueIndex;

    public override define DisplayName: CurrentValue.Name;

    public MenuListOption(){

    }

    public MenuListOption(ref MenuOptionValue[] _values){
        values = _values;
    }

    public void AddOptionValue(ref define _value, ref define _name){
        values = Append(values, new MenuOptionValue(_value, _name));
    }

    public void AddOptionValue(ref MenuOptionValue val){
        values = Append(values, val);
    }

    public override void SetCurrentValue(ref define _index){
        currentValueIndex = RoundToInteger((Max(Min(CountOf(values), _index), -1)), Rounding.Down);
        if(currentValueIndex <= -1)
            currentValueIndex = CountOf(values) - 1;
        else if(currentValueIndex >= CountOf(values)){
            currentValueIndex = 0;
        }
    }

    public override void ModifyCurrentValue(ref define difference){
        SetCurrentValue(currentValueIndex + difference);
    }

}

struct MenuFloatOption : MenuOption {

    private MenuOptionValue value;
    public override MenuOptionValue CurrentValue: value;

    public override define DisplayName: <"<0>: <1>", value.Name, value.Value>; 

    private define min;
    private define max;

    public MenuFloatOption(ref define name, ref define startingValue, ref define _min, ref define _max){
        value = new MenuOptionValue(startingValue, name);
        min = _min;
        max = _max;
    }

    public override void SetCurrentValue(ref define newVal){
        value.SetValue(Min(max, Max(min, newVal)));
    }

     public override void ModifyCurrentValue(ref define difference){
         SetCurrentValue(value.Value+difference);
    }

}

struct MenuButtonOption : MenuOption {

    private MenuTriggerValue value;

    public override MenuTriggerValue CurrentValue: value;

    public override define DisplayName: value.Name;

    public define IsActive: value.Value;


    public MenuButtonOption(define _name){
        value = new MenuTriggerValue(_name);
    }

    public void Activate(){
        value.Activate();
    }

}

struct MenuOption {

    public define index;
    public define textId;


    public virtual define DisplayName: null;

    public virtual AbstractMenuOptionValue CurrentValue: null;

    public virtual void SetCurrentValue(ref define newVal){
    }

    public virtual void ModifyCurrentValue(ref define difference){
    }
}
//End of MenuOptions


//MenuOptionValues
struct MenuTriggerValue : AbstractMenuOptionValue {

    Trigger trigger = new Trigger();

    public define IsActive: trigger.IsActive;

    public MenuTriggerValue(ref define _name){
        name = _name;
    }

   public void Activate(){
        value = true;
        trigger.Activate();
        value = false;
    }

    public override void SetValue(ref define newValue){}
}

struct MenuOptionValue : AbstractMenuOptionValue {
    
    public MenuOptionValue(ref define _value, ref define _name){
        value = _value;
        name = _name;
    } 
}

struct AbstractMenuOptionValue {
    protected define value;
    protected define name;

    public define Value: value;
    public define Name: name;

    // public static MenuOptionValue GenerateValue(ref define _value, ref define _name){
    //     MenuOptionValue menOptVal = new MenuOptionValue(_value, _name);
        
    //     return menOptVal;
    // }

    public virtual void SetValue(ref define newValue){
        value = newValue;
    }
}
//End Of MenuOptionValues