import { Consequence, DamageFormula, Condition, StatusEffect } from '../combat'
import { Creature } from '../creature'
import { LogEntry, LogLines, LogLine, nilLog } from '../interface'
import { Verb, PairLine } from '../language'

/**
 * Takes a function, and thus can do anything.
 */
export class ArbitraryConsequence extends Consequence {
  constructor (public apply: (user: Creature, target: Creature) => LogEntry, conditions: Condition[] = []) {
    super(conditions)
  }

  describeSolo (user: Creature): LogEntry {
    return nilLog
  }

  describePair (user: Creature): LogEntry {
    return nilLog
  }
}

/**
 * Renders some text.
 */

export class LogConsequence extends Consequence {
  constructor (private line: PairLine<Creature>, conditions: Condition[] = []) {
    super(conditions)
  }

  apply (user: Creature, target: Creature): LogEntry {
    return this.line(user, target)
  }
}

/**
 * Deals damage.
 */
export class DamageConsequence extends Consequence {
  constructor (private damageFormula: DamageFormula, conditions: Condition[] = []) {
    super(conditions)
  }

  apply (user: Creature, target: Creature): LogEntry {
    const damage = this.damageFormula.calc(user, target)
    return new LogLines(
      new LogLine(`${target.name.capital} ${target.name.conjugate(new Verb('take'))} `, damage.renderShort(), ` damage!`),
      target.takeDamage(damage)
    )
  }

  describePair (user: Creature, target: Creature): LogEntry {
    return new LogLine(
      this.damageFormula.describe(user, target)
    )
  }
}

/**
 * Same as [[DamageConsequence]], but it has healing text
 */
export class HealingConsequence extends Consequence {
  constructor (private damageFormula: DamageFormula, conditions: Condition[] = []) {
    super(conditions)
  }

  apply (user: Creature, target: Creature): LogEntry {
    const damage = this.damageFormula.calc(user, target)
    return new LogLines(
      new LogLine(`${target.name.capital} ${target.name.conjugate(new Verb('heal'))} `, damage.renderShort(), `!`),
      target.takeDamage(damage)
    )
  }

  describePair (user: Creature, target: Creature): LogEntry {
    return new LogLine(
      `Heals for `,
      this.damageFormula.describe(user, target)
    )
  }
}

/**
 * Applies a status effect
 */
export class StatusConsequence extends Consequence {
  constructor (private statusMaker: () => StatusEffect, conditions: Condition[] = []) {
    super(conditions)
  }

  apply (user: Creature, target: Creature): LogEntry {
    return target.applyEffect(this.statusMaker())
  }

  describePair (user: Creature, target: Creature): LogEntry {
    return new LogLine(
      `Applies a ${this.statusMaker().name} effect.`
    )
  }
}