import { getThralls, ItemStage, LifeStage, Thrall } from "./thralls.ts";
import { CellView, CheckData } from "./newmap.ts";
import { getPlayerProgress } from "./playerprogress.ts";
import { getHuntMode, HuntMode, initHuntMode } from "./huntmode.ts";
import { generateMap } from "./mapgen.ts";
import { ALL_STATS, Stat } from "./datatypes.ts";
import { D } from "./engine/public.ts";
import {
  sprLadder,
  sprLock,
  sprResourcePickup,
  sprStatPickup,
} from "./sprites.ts";
import { GridArt } from "./gridart.ts";
import { getCheckModal } from "./checkmodal.ts";
import { Point, Size } from "./engine/datatypes.ts";
import { choose } from "./utils.ts";
import { FG_TEXT } from "./colors.ts";

export type Pickup =
  | LockPickup
  | StatPickup
  | ExperiencePickup
  | LadderPickup
  | ThrallPickup
  | ThrallPosterPickup
  | ThrallRecruitedPickup;

export class LockPickup {
  check: CheckData;

  constructor(check: CheckData) {
    this.check = check;
  }

  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return true;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    for (let z = 0; z < 5; z += 0.25) {
      D.drawSprite(sprLock, gridArt.project(z), 0, {
        xScale: 2.0,
        yScale: 2.0,
      });
    }
  }

  onClick(cell: CellView): boolean {
    getCheckModal().show(this.check, () => (cell.pickup = null));
    return true;
  }
}

export class StatPickup {
  stat: Stat;

  constructor(stat: Stat) {
    this.stat = stat;
  }

  computeCostToClick() {
    return 100;
  }

  isObstructive() {
    return true;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let statIndex = ALL_STATS.indexOf(this.stat);
    if (statIndex == -1) {
      return;
    }

    D.drawSprite(sprStatPickup, gridArt.project(5), statIndex, {
      xScale: 2,
      yScale: 2,
    });
  }

  onClick(): boolean {
    getPlayerProgress().add(this.stat, 1);
    getPlayerProgress().purloinItem();
    return false;
  }
}

export class ExperiencePickup {
  computeCostToClick() {
    return 100;
  }

  isObstructive() {
    return true;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    D.drawSprite(
      sprResourcePickup,
      gridArt.project(0.0).offset(new Point(0, -16)),
      0,
      {
        xScale: 2,
        yScale: 2,
      },
    );
  }

  onClick(): boolean {
    getPlayerProgress().addExperience(250);
    getPlayerProgress().purloinItem();
    return false;
  }
}

export class LadderPickup {
  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return false;
  }

  drawFloor(gridArt: GridArt) {
    D.drawSprite(sprLadder, gridArt.project(0.0), 0, {
      xScale: 2.0,
      yScale: 2.0,
    });
  }
  drawInAir() {}

  onClick(): boolean {
    getPlayerProgress().addBlood(1000);
    initHuntMode(new HuntMode(getHuntMode().depth + 1, generateMap()));
    return false;
  }
}

export class ThrallPickup {
  thrall: Thrall;

  constructor(thrall: Thrall) {
    this.thrall = thrall;
  }

  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return false;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let data = getThralls().get(this.thrall);
    D.drawSprite(data.sprite, gridArt.project(0.0), 0, {
      xScale: 2.0,
      yScale: 2.0,
    });
  }

  onClick(cell: CellView): boolean {
    let data = getThralls().get(this.thrall);
    getCheckModal().show(data.initialCheck, () => {
      getPlayerProgress().unlockThrall(this.thrall);
      cell.pickup = null;
    });
    return true;
  }
}

export class ThrallPosterPickup {
  thrall: Thrall;

  constructor(thrall: Thrall) {
    this.thrall = thrall;
  }

  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return false;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let data = getThralls().get(this.thrall);
    D.drawSprite(data.sprite, gridArt.project(0.0), 2, {
      xScale: 2.0,
      yScale: 2.0,
    });
  }

  onClick(cell: CellView): boolean {
    let data = getThralls().get(this.thrall);
    getCheckModal().show(data.posterCheck, () => (cell.pickup = null));
    return true;
  }
}

export class ThrallRecruitedPickup {
  thrall: Thrall;
  bitten: boolean;

  constructor(thrall: Thrall) {
    this.thrall = thrall;
    this.bitten = false;
  }

  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return false;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let data = getThralls().get(this.thrall);
    let lifeStage = getPlayerProgress().getThrallLifeStage(this.thrall);
    let ix = 0;
    let rot = 0;

    if (lifeStage == LifeStage.Vampirized) {
      ix = 1;
    }
    if (lifeStage == LifeStage.Dead) {
      ix = 1;
      rot = 270;
    }
    D.drawSprite(data.sprite, gridArt.project(0.0), ix, {
      xScale: 2.0,
      yScale: 2.0,
      angle: rot,
    });
  }

  onClick(_cell: CellView): boolean {
    if (this.bitten) {
      return true;
    }

    let data = getThralls().get(this.thrall);
    let lifeStage = getPlayerProgress().getThrallLifeStage(this.thrall);
    let text = data.lifeStageText[lifeStage];
    getCheckModal().show(
      {
        label: `${text.prebite}`,
        options: [
          {
            isChoice: true,
            countsAsSuccess: true,
            unlockable: "Bite!",
            success: text.postbite,
          },
          {
            isChoice: true,
            countsAsSuccess: false,
            unlockable: "Refrain",
            success: "Maybe next time.",
          },
        ],
      },
      () => {
        this.bitten = true;
        getPlayerProgress().addBlood(
          lifeStage == LifeStage.Fresh
            ? 1000
            : lifeStage == LifeStage.Average
              ? 500
              : lifeStage == LifeStage.Poor
                ? 300
                : lifeStage == LifeStage.Vampirized
                  ? 1500 // lethal bite
                  : // lifeStage == LifeStage.Dead ?
                    100,
        );
        getPlayerProgress().damageThrall(this.thrall, choose([0.9]));
      },
    );
    return true;
  }
}

export class ThrallCollectionPlatePickup {
  thrall: Thrall;
  rewarded: boolean;

  constructor(thrall: Thrall) {
    this.thrall = thrall;
    this.rewarded = false;
  }

  computeCostToClick() {
    return 0;
  }

  isObstructive() {
    return false;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let itemStage = getPlayerProgress().getThrallItemStage(this.thrall);
    let data = getThralls().get(this.thrall);

    if (itemStage != ItemStage.Delivered) {
      D.drawRect(
        gridArt.project(0).offset(new Point(-18, -18)),
        new Size(36, 36),
        FG_TEXT,
      );
    } else {
      D.drawSprite(data.sprite, gridArt.project(2), 3, {
        xScale: 2.0,
        yScale: 2.0,
      });
    }
  }

  onClick(cell: CellView): boolean {
    let lifeStage = getPlayerProgress().getThrallLifeStage(this.thrall);
    let itemStage = getPlayerProgress().getThrallItemStage(this.thrall);
    let data = getThralls().get(this.thrall);

    // if (itemStage == ItemStage.Untouched) { itemStage = ItemStage.Obtained; }

    if (itemStage == ItemStage.Untouched) {
      if (lifeStage == LifeStage.Dead) {
        getCheckModal().show(
          {
            label: "There's no point in delivering this now.",
            options: [],
          },
          null,
        );
      } else {
        getCheckModal().show(
          {
            label: data.itemHint,
            options: [],
          },
          null,
        );
      }
    } else if (itemStage == ItemStage.Obtained) {
      getPlayerProgress().deliverThrallItem(this.thrall);
      if (lifeStage != LifeStage.Dead) {
        getCheckModal().show(
          {
            label: data.deliveryMessage,
            options: [],
          },
          null,
        );
      }
    } else {
      if (lifeStage == LifeStage.Dead) {
        // nothing happens
      } else if (this.rewarded) {
        // nothing happens
      } else {
        this.rewarded = true;
        getCheckModal().show(
          {
            label: data.rewardMessage,
            options: [],
          },
          null,
        );
        data.rewardCallback();
      }
    }

    // getCheckModal().show(this.check, () => (cell.pickup = null));
    return true;
  }
}

export class ThrallItemPickup {
  thrall: Thrall;

  constructor(thrall: Thrall) {
    this.thrall = thrall;
  }

  computeCostToClick() {
    return 100;
  }

  isObstructive() {
    return false;
  }

  drawFloor() {}
  drawInAir(gridArt: GridArt) {
    let data = getThralls().get(this.thrall);

    D.drawSprite(data.sprite, gridArt.project(2), 3, {
      xScale: 2.0,
      yScale: 2.0,
    });
  }

  onClick(cell: CellView): boolean {
    let data = getThralls().get(this.thrall);

    cell.pickup = null;
    getCheckModal().show(
      {
        label: data.itemPickupMessage,
        options: [],
      },
      null,
    );
    getPlayerProgress().obtainThrallItem(this.thrall);
    return true;
  }
}