import { Evaluated } from '@league-of-foundry-developers/foundry-vtt-types/src/foundry/client/dice/roll';
import { M5Character } from '../actors/M5Character';
import { M5EwResult, M5ModOperation, M5ModType, M5RollData, M5RollResult, M5SkillUnlearned, M5Stats } from '../M5Base';
import { stat } from 'fs';

export class M5Roll {
  // extends Roll<M5RollData>
  static readonly TEMPLATE_PATH = 'systems/midgard5/templates/chat/roll-m5.hbs';

  public _evaluated: boolean = false;
  public _total: number = 0;
  public pool: PoolTerm = null;

  constructor(
    public data: M5RollData,
    public actor: any,
    public label: string
  ) {
    //super(null)
    //this.data = rollData
  }

  // @ts-ignore
  //override evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): Evaluated<Roll<M5RollData>> | Promise<Evaluated<Roll<M5RollData>>> {
  evaluate() {
    const indexMap = new Map<number, string>();
    const rollNames = Object.keys(this.data.rolls);
    const rolls = rollNames
      .filter(rollName => this.data.rolls[rollName].enabled)
      .map((rollName, index) => {
        indexMap.set(index, rollName);
        const formula = this.data.rolls[rollName];
        const roll = new Roll(formula.formula, this.data);
        return roll;
      });

    this.pool = PoolTerm.fromRolls(rolls);
    console.log('evaluate', this._evaluated, this.pool);
    return this.pool.evaluate({ async: true }).then(results => {
      this._total = 0;

      results.rolls.forEach((roll, index) => {
        const rollIndex = indexMap.get(index);
        const rollResult = this.data.rolls[rollIndex] as M5RollResult;

        rollResult.result = roll.result;
        rollResult.total = roll.total;
        rollResult.totalStr = roll.total.toString();

        this._total += roll.total;

        let rowRes = M5EwResult.TBD;
        let face100 = -1;

        roll.dice.forEach((d, dIndex) => {
          rollResult.dice[dIndex.toString()] = d.total;

          if (rowRes === M5EwResult.TBD && dIndex === 0) {
            if (d.faces === 20) {
              //if (rollResult.type === "ew") {
              if (d.total === 1) rowRes = M5EwResult.FUMBLE;
              else if (d.total === 20) rowRes = M5EwResult.CRITICAL;
              else if (d.total >= 16) rowRes = M5EwResult.HIGH;
            } else if (d.faces === 100) {
              face100 = d.total as number;
            }
          }
        });

        const parseResult = M5Roll.parseDiceSides(rollResult.formula);
        //console.log("evaluate roll", parseResult)
        if (parseResult?.sides === 20) {
          if (roll.total < 20) {
            if (rowRes === M5EwResult.TBD || rowRes === M5EwResult.HIGH) rowRes = M5EwResult.FAIL;
          } else {
            if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.PASS;
          }
        } else if (face100 >= 0) {
          const threshold100 = roll.total + face100;
          const threshold = Math.floor(threshold100 / 10);
          if (face100 === 100) {
            if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.FUMBLE;
          } else if (roll.total < 0) {
            if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.FAIL;
          } else if (face100 <= threshold) {
            if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.CRITICAL;
          } else {
            if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.PASS;
          }
        }
        rollResult.css = rowRes;
      });

      this.data.res.label = this.label;

      this._evaluated = true;
      return this;
    });
  }

  async render(): Promise<string> {
    return renderTemplate(M5Roll.TEMPLATE_PATH, this.data);
  }

  async toMessage() {
    if (!this._evaluated) await this.evaluate();

    const rMode = (game as Game).settings.get('core', 'rollMode');

    const chatData = {
      type: CONST.CHAT_MESSAGE_TYPES.ROLL,
      content: await this.render(),
      speaker: ChatMessage.getSpeaker({ actor: this.actor }),
      sound: CONFIG.sounds.dice,
      roll: Roll.fromTerms([this.pool]),
    };

    ChatMessage.applyRollMode(chatData, rMode);
    return ChatMessage.create(chatData);
  }

  static fromAttributeValue(actor: any, attributeKey: string, attributeValue: number) {
    const rollData = actor.getRollData() as M5RollData;
    const itemData = actor.items.filter(x => x.type === 'effect').map(y => y.system.mods);
    rollData.c = 0;
    for (let effectKey in itemData) {
      for (let modkey in itemData[effectKey])
        if (
          itemData[effectKey][modkey].type === M5ModType.ATTRIBUTE &&
          itemData[effectKey][modkey].operation === M5ModOperation.ROLL
        ) {
          rollData.c += itemData[effectKey][modkey].value;
        }
    }

    rollData.i = attributeValue;
    rollData.rolls['0'] = {
      formula: '@i - 1d100 - @c',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.pw'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize(`midgard5.actor-${attributeKey}-long`));
  }

  static fromUnlearnedSkill(actor: any, skill: M5SkillUnlearned, skillName: string) {
    const rollData = actor.getRollData() as M5RollData;
    rollData.i = {
      fw: skill.fw,
      bonus: actor.system.calc?.attributes[skill.attribute]?.bonus ?? 0,
    };
    rollData.iType = 'skill';

    rollData.rolls['0'] = {
      formula: '1d20 + @i.fw + @i.bonus',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.pw'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize(`midgard5.${skillName}`));
  }

  static brawl(actor: any) {
    const rollData = actor.getRollData() as M5RollData;
    rollData.i = {
      attackBonus: 0,
      damageBonus: 0,
    };

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.brawlFw',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.attack'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    rollData.rolls['1'] = {
      formula: '1d6 - 4 + @c.calc.stats.damageBonus.value',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.damage'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.brawl'));
  }

  static perception(actor: any) {
    const rollData = actor.getRollData() as M5RollData;

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.perception.value + @c.calc.stats.perceptionFW',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.perception'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.perception'));
  }

  static drinking(actor: any) {
    const rollData = actor.getRollData() as M5RollData;

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.drinking.value + @c.calc.stats.drinkingFW',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.drinking'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.drinking'));
  }

  static defense(actor: any) {
    const rollData = actor.getRollData() as M5RollData;
    rollData.i = {
      defenseBonus: 0,
    };

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.defense.value + @c.calc.stats.defenseBonus.value',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.defense'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.defense'));
  }

  static resistanceMind(actor: any) {
    const rollData = actor.getRollData() as M5RollData;
    rollData.i = {
      defenseBonus: 0,
    };

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.resistanceMind.value',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.resistanceMind'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.resistanceMind'));
  }

  static resistanceBody(actor: any) {
    const rollData = actor.getRollData() as M5RollData;
    rollData.i = {
      defenseBonus: 0,
    };

    rollData.rolls['0'] = {
      formula: '1d20 + @c.calc.stats.resistanceBody.value',
      enabled: true,
      label: (game as Game).i18n.localize('midgard5.resistanceBody'),
      result: '',
      total: 0,
      totalStr: '',
      dice: {},
      css: '',
    } as M5RollResult;

    return new M5Roll(rollData, actor, (game as Game).i18n.localize('midgard5.resistanceBody'));
  }

  static parseDiceSides(formula: string): FormulaParseResult {
    const ewMatcher: RegExp = /\d*[dD]20/g;
    const pwMatcher: RegExp = /(\d+)\s*\-\s*\d*[dD]100/g;

    let res = formula.match(ewMatcher);
    if (res && !!res[0]) {
      return {
        sides: 20,
        type: 'ew',
        threshold: null,
      };
    }

    res = formula.match(pwMatcher);
    if (res && !!res[1]) {
      return {
        sides: 100,
        type: 'pw',
        threshold: parseInt(res[1]),
      };
    }

    return null;
  }
}

interface FormulaParseResult {
  sides: number;
  type: string;
  threshold: number;
}