import type { MAIN_STATS, ABILITIES, LEVELS, TRAINING_LEVELS, SPELL_TYPES, CATEGORIES, SPELL_ELEMENTS } from "~/shared/character";

export type MainStat = typeof MAIN_STATS[number];
export type Ability = typeof ABILITIES[number];
export type Level = typeof LEVELS[number];
export type TrainingLevel = typeof TRAINING_LEVELS[number];
export type SpellType = typeof SPELL_TYPES[number];
export type Category = typeof CATEGORIES[number];
export type SpellElement = typeof SPELL_ELEMENTS[number];

export type DoubleIndex<T extends number | string> = [T, number];

export type Character = {
    id: number;

    name: string;
    people?: number;
    level: number;
    aspect?: number;
    notes?: string | null;
    health: number;
    mana: number;

    training: Record<MainStat, DoubleIndex<TrainingLevel>[]>;
    leveling: DoubleIndex<Level>[];
    abilities: Partial<Record<Ability, [number, number]>>; //First is the ability, second is the max increment
    spells: string[]; //Spell ID
    modifiers: Partial<Record<MainStat, number>>;

    choices: Record<string, number[]>;

    owner: number;
    username?: string;
    visibility: "private" | "public";
};
export type CharacterValues = {
    health: number;
    mana: number;
};
export type CharacterConfig = {
    peoples: Race[],
    training: Record<MainStat, Record<TrainingLevel, TrainingOption[]>>;
    abilities: Record<Ability, AbilityConfig>;
    spells: SpellConfig[];
};
export type SpellConfig = {
    id: string;
    name: string;
    rank: 1 | 2 | 3 | 4;
    type: SpellType;
    cost: number;
    speed: "action" | "reaction" | number;
    elements: Array<SpellElement>;
    effect: string;
    tags?: string[];
};
export type AbilityConfig = {
    max: [MainStat, MainStat];
    name: string;
    description: string;
};
export type Race = {
    name: string;
    description: string;
    options: Record<Level, Feature[]>;
};

export type FeatureEffect = {
    category: "value";
    operation: "add" | "set";
    property: string;
    value: number | `modifier/${MainStat}`;
} | {
    category: "feature";
    kind: "action" | "reaction" | "freeaction" | "passive";
    text: string;
} | {
    category: "list";
    list: "spells";
    action: "add" | "remove";
    item: string;
};
export type FeatureItem = FeatureEffect | {
    category: "choice";
    id: string;
    settings?: { //If undefined, amount is 1 by default
        amount: number;
        exclusive: boolean; //Disallow to pick the same option twice
    };
    options: FeatureEffect[];
}
export type Feature = {
    name?: string;
    description: string;
    effect: FeatureItem[];
};

export type TrainingOption = {
    description: Array<{
        text: string;
        disposable?: boolean;
        replaced?: boolean;
        category?: Category;
    }>;

    //Automatically calculated by compiler
    mana?: number;
    health?: number;
    speed?: false | number;
    initiative?: number;
    mastery?: keyof CompiledCharacter["mastery"];
    spellrank?: SpellType;
    defense?: Array<keyof CompiledCharacter["defense"]>;
    resistance?: Record<MainStat, number>;
    bonus?: Record<string, number>;
    spell?: string; 

    //Used during character creation, not used by compiler
    modifier?: number;
    ability?: number;
    spec?: number; 
    spellslot?: number | MainStat;
    arts?: number | MainStat;

    features?: FeatureItem[]; //TODO
};
export type CompiledCharacter = {
    id: number;
    owner?: number;
    username?: string;
    name: string;
    health: number;
    mana: number;
    race: number;
    spellslots: number;
    artslots: number;
    spellranks: Record<SpellType, 0 | 1 | 2 | 3>;
    aspect: string;
    speed: number | false;
    initiative: number;
    spells: string[];

    values: CharacterValues,

    defense: {
        hardcap: number;
        static: number;
        activeparry: number;
        activedodge: number;
        passiveparry: number;
        passivedodge: number;
    };

    mastery: {
        strength: number;
        dexterity: number;
        shield: number;
        armor: number;
        multiattack: number;
        magicpower: number;
        magicspeed: number;
        magicelement: number;
        magicinstinct: number;
    };

    bonus: Record<string, number>; //Any special bonus goes here
    resistance: Record<string, number>;

    modifier: Record<MainStat, number>;
    abilities: Partial<Record<Ability, number>>;
    level: number;
    features: { [K in Extract<FeatureEffect, { category: "feature" }>["kind"]]: string[] };

    notes: string;
};