import { Creature } from "../creature"
import { Damage, DamageType, ConstantDamageFormula, Vigor, Side, CompositionAction } from '../combat'
import { MalePronouns, ImproperNoun, ProperNoun, Verb } from '../language'
import { VoreType, Stomach, Bowels, Cock, Balls, biconnectContainers, Hand } from '../vore'
import { TransferAction, FeedAction } from '../combat/actions'
import { StatusConsequence, LogConsequence, ArbitraryConsequence } from '../combat/consequences'
import { SizeEffect, InstantKillEffect } from '../combat/effects'
import { LogLine, nilLog } from '../interface'
import { TogetherCondition, MassRatioCondition, ContainsCondition } from '../combat/conditions'
import { ChanceTest } from '../combat/tests'

export class Geta extends Creature {
  constructor () {
    super(
      new ProperNoun('Geta'),
      new ImproperNoun('fox', 'foxes'),
      MalePronouns,
      { Toughness: 10, Power: 10, Reflexes: 30, Agility: 30, Willpower: 15, Charm: 40 },
      new Set([VoreType.Oral, VoreType.Anal, VoreType.Cock]),
      new Set([VoreType.Oral, VoreType.Anal, VoreType.Cock]),
      40
    )

    this.side = Side.Monsters

    const stomach = new Stomach(this, 0.25, new ConstantDamageFormula(new Damage(
      { amount: 100, type: DamageType.Acid, target: Vigor.Health },
      { amount: 40, type: DamageType.Crush, target: Vigor.Stamina },
      { amount: 80, type: DamageType.Dominance, target: Vigor.Resolve }
    )))
    this.containers.push(stomach)

    const bowels = new Bowels(this, 0.25, new ConstantDamageFormula(new Damage(
      { amount: 30, type: DamageType.Crush, target: Vigor.Health },
      { amount: 90, type: DamageType.Crush, target: Vigor.Stamina },
      { amount: 120, type: DamageType.Dominance, target: Vigor.Resolve }
    )))

    this.containers.push(bowels)

    this.actions.push(new TransferAction(bowels, stomach))

    this.otherActions.push(new FeedAction(stomach))

    const cock = new class extends Cock {
      digestLine (user: Creature, target: Creature) {
        return new LogLine(`${user.name.capital.possessive} ${this.name} throbs as it abruptly absorbs ${target.name.objective}, transforming ${target.name.objective} into more of ${user.pronouns.possessive} meaty shaft.`)
      }
    }(this, 0.25, new ConstantDamageFormula(new Damage(
      { amount: 10, type: DamageType.Crush, target: Vigor.Health },
      { amount: 50, type: DamageType.Crush, target: Vigor.Stamina },
      { amount: 150, type: DamageType.Dominance, target: Vigor.Resolve }
    )))

    cock.actions.push(
      new CompositionAction(
        "Clench",
        "Try to crush the life from your cock-snack",
        {
          conditions: [
            new ContainsCondition(cock)
          ],
          tests: [
            new ChanceTest(
              0.5,
              (user, target) => new LogLine(
                  `${user.name.capital.possessive} cock clenches hard around ${target.name.objective}, but ${target.pronouns.subjective} ${target.name.conjugate(new Verb("avoid"))} being crushed.`
              )
            )
          ],
          consequences: [
            new LogConsequence(
              (user, target) => new LogLine(
                `${user.name.capital} ${user.name.conjugate(new Verb('let'))} out a lustful moan as ${user.pronouns.subjective} crushes the life from ${target.name.possessive} body with a flex of ${user.pronouns.possessive} shaft.`
              )
            ),
            new StatusConsequence(
              () => new InstantKillEffect()
            ),
            new ArbitraryConsequence(
              () => cock.tick(0),
              () => nilLog
            )
          ]
        }
      )
    )

    const balls = new Balls(this, 0.25, new ConstantDamageFormula(new Damage(
      { amount: 50, type: DamageType.Acid, target: Vigor.Health },
      { amount: 25, type: DamageType.Crush, target: Vigor.Stamina },
      { amount: 50, type: DamageType.Dominance, target: Vigor.Resolve }
    )), cock)

    this.containers.push(balls)
    this.containers.push(cock)

    biconnectContainers(cock, balls)

    cock.onDigest = () => nilLog

    const shrinkAction = new CompositionAction(
      "Shrink",
      "Zap!",
      {
        conditions: [
          new TogetherCondition()
        ],
        consequences: [
          new LogConsequence(
            () => new LogLine(`ZAP!`)
          ),
          new StatusConsequence(
            () => new SizeEffect(0.1)
          )
        ]
      }
    )
    this.actions.push(
      shrinkAction
    )

    this.otherActions.push(
      shrinkAction
    )

    const crushAction = new CompositionAction(
      "Crush",
      "Crush them like a bug underfoot",
      {
        conditions: [
          new TogetherCondition(),
          new MassRatioCondition(10)
        ],
        consequences: [
          new LogConsequence(
            (user, target) => new LogLine(
              `${user.name.capital} ${user.name.conjugate(new Verb("raise"))} ${user.pronouns.possessive} paw over ${target.name.objective}, stomping down hard and crushing the life from ${user.pronouns.possessive} prey with a sickening CRUNCH.`
            )
          ),
          new StatusConsequence(
            () => new InstantKillEffect()
          )
        ]
      }
    )

    this.actions.push(
      crushAction
    )

    this.otherActions.push(
      crushAction
    )

    const hand = new Hand(this, 0.25)

    this.otherContainers.push(
      hand
    )

    this.actions.push(
      new CompositionAction(
        "Devour",
        "Pop your prey into your mouth",
        {
          conditions: [
            new ContainsCondition(hand)
          ],
          consequences: [
            new ArbitraryConsequence(
              (user, target) => stomach.consume(target),
              () => new LogLine(`Devours the target.`)
            )
          ]
        }
      )
    )

    this.actions.push(
      new CompositionAction(
        "Grip",
        "Squeeze your prey like a grape",
        {
          conditions: [
            new ContainsCondition(hand)
          ],
          consequences: [
            new LogConsequence(
              (user, target) => new LogLine(
                `${user.name.capital} ${user.name.conjugate(new Verb("crush", "crushes"))} ${target.name.objective} in ${user.pronouns.possessive} merciless grip, breaking bones and pulping ${user.pronouns.possessive} victim with ease.`
              )
            ),
            new StatusConsequence(
              () => new InstantKillEffect()
            )
          ]
        }
      )
    )
  }
}