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

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 FeatureID = string;
export type Alignment = { loyalty: 'loyal' | 'neutral' | 'chaotic', kindness: 'good' | 'neutral' | 'evil' };

export type Character = {
    id: number;

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

    training: Record<MainStat, Partial<Record<TrainingLevel, number>>>;
    leveling: Partial<Record<Level, number>>;
    abilities: Partial<Record<Ability, 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 CharacterVariables = {
    health: number;
    mana: number;
    
    sickness: Array<{ id: string, progress: number | true }>;
    equipment: Array<string>;
};
export type CharacterConfig = {
    peoples: RaceConfig[],
    training: Record<MainStat, Record<TrainingLevel, FeatureID[]>>;
    abilities: Record<Ability, AbilityConfig>;
    spells: SpellConfig[];
    aspects: AspectConfig[];
    features: Record<FeatureID, Feature>;
    lists: Record<string, { id: string, name: string, [key: string]: any }[]>;
};
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 RaceConfig = {
    name: string;
    description: string;
    options: Record<Level, FeatureID[]>;
};
export type AspectConfig = {
    name: string;
    description: string;
    stat: MainStat | 'special';
    alignment: Alignment;
    magic: boolean;
    difficulty: number;
    physic: { min: number, max: number };
    mental: { min: number, max: number };
    personality: { min: number, max: number };
    options: FeatureEffect[];
};

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

export type CompiledCharacter = {
    id: number;
    owner?: number;
    username?: string;
    name: string;
    health: number; //Max
    mana: number; //Max
    race: number;
    spellslots: number; //Max
    artslots: number; //Max
    spellranks: Record<SpellType, 0 | 1 | 2 | 3>;
    aspect: string; //ID
    speed: number | false;
    capacity: number | false;
    initiative: number;

    variables: CharacterVariables,

    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;
    lists: { [K in Extract<FeatureEffect, { category: "list" }>["list"]]?: string[] };

    notes: string;
};