import {
  world,
  system,
  Vector3,
  MolangVariableMap,
  ChatSendAfterEvent,
  Dimension,
  TicksPerSecond,
  BlockVolume,
} from "@minecraft/server";
import { Mindkeeper, StoreType } from "./Commandeer/mindKeeper";
import Pupeteer from "./Commandeer/pupeteer";
import { Vector3ToCommandString, Vector3ToFancyString, vector3 } from "./Commandeer/utils/vectorUtils";
import { delay } from "./Commandeer/utils/waitUtil";
import { spawnParticle } from "./Commandeer/utils/particleUtils";
import { TrailMaker } from "./Commandeer/trail/trailMaker";
import * as CCTrigger from "./Commandeer/Trigger/CCTrigger";
import { Commands } from "./Commandeer/command/command";
import { Trail } from "./Commandeer/trail/trailEngine";
import { startTrail } from "./trails/startTrail";
import level1 from "./levels/level1/mission1";
import level2 from "./levels/level2/mission1";
import level3 from "./levels/level2/mission2";
import level4 from "./levels/level2/mission3";
import level5 from "./levels/level3/mission1";
import { MinecraftBlockTypes } from "./vanilla-data/mojang-block";
import { TransitionTrailToLevel2 } from "./trails/TransitionTrailToLevel2";
import { TransitionTrailToLevel3 } from "./trails/TransitionTrailToLevel3";
import { TransitionTrailToLevel4 } from "./trails/TransitionTrailToLevel4";
import { TransitionTrailToLevel5 } from "./trails/TransitionTrailToLevel5";
import { TransitionTrailToTheEnd } from "./trails/TransitionTrailToTheEnd";

const mindKeeper = new Mindkeeper(world);
const trailMaker: TrailMaker.Maker = new TrailMaker.Maker();
const triggerManager = new CCTrigger.Manager(mindKeeper);
const CURRENT_LEVEL = "currentLevel";
const AGENT_ID = "agentid";
const PREFIX = "!";
export { mindKeeper, CURRENT_LEVEL, triggerManager };

let introTrail: Trail = new Trail("introTrail", 4, 4);
introTrail.fromTrail(startTrail);

let transitionTrail1 = new Trail("transitionTrail1", 2, 2);
transitionTrail1.fromTrail(TransitionTrailToLevel2);

let transitionTrail2 = new Trail("transitionTrail2", 2, 2);
transitionTrail2.fromTrail(TransitionTrailToLevel3);

let transitionTrail3 = new Trail("transitionTrail3", 2, 2);
transitionTrail3.fromTrail(TransitionTrailToLevel4);

let transitionTrail4 = new Trail("transitionTrail4", 2, 2);
transitionTrail4.fromTrail(TransitionTrailToLevel5);

let transitionTrail5 = new Trail("transitionTrail5", 2, 2);
transitionTrail5.fromTrail(TransitionTrailToTheEnd);

const frameDuration = 7;
let gateRoot = vector3(-226, 68, 223);
enum GateState {
  open,
  closed,
}
let gateState = GateState.closed;

const DEVELOPER_MODE = true;
let tickCounter = 0;
system.runInterval(async () => {
  tickCounter++;
  if (mindKeeper.initialised) {
    trailMaker.Update();
    if (tickCounter % 2 == 0) {
      triggerManager.Update();
    }

    const currentLevel = mindKeeper.get(CURRENT_LEVEL);
    switch (currentLevel) {
      case 0:
        Pupeteer.setActionBar("Leave the treehouse and go down the ladder.");
        introTrail.spawnNext();
        break;
      case 1:
        level1.update();
        break;

      case 2:
        Pupeteer.setActionBar("Follow the trail to the next level.");
        transitionTrail1.spawnNext();
        break;

      case 3:
        level2.update();
        break;

      case 4:
        Pupeteer.setActionBar("Follow the trail to the next level.");
        transitionTrail2.spawnNext();
        break;

      case 5:
        level3.update();
        break;

      case 6:
        Pupeteer.setActionBar("Follow the trail to the next level.");
        transitionTrail3.spawnNext();
        break;

      case 7:
        level4.update();
        break;

      case 8:
        Pupeteer.setActionBar("Follow the trail to the next level.");
        transitionTrail4.spawnNext();
        break;

      case 9:
        level5.update();
        break;
      case 10:
        transitionTrail5.spawnNext();
        if (gateState == GateState.closed) {
          PlayGateOpenAnimation();
          gateState = GateState.open;
        }
        break;
      case 11:
        Pupeteer.setActionBar("You completed the mission.");
    }
  }
});

world.afterEvents.chatSend.subscribe(async (event: ChatSendAfterEvent) => {
  const command = event.message.split(" ")[0];

  trailMaker.OnChat(event);
  mindKeeper.chatCommands(event);
  triggerManager.OnChat(event);

  if (command === "!reset") {
    world.sendMessage("Resetting");
    level1.reset();
    level2.reset();
    level3.reset();
    level4.reset();
    level5.reset();
    ResetGate();
    world.getDimension("Overworld").runCommand("/fill -86 71 253 -86 75 275 barrier replace air");
    world.getDimension("Overworld").runCommand("/fill -128 71 255 -128 74 276 barrier replace air");
    world.getDimension("Overworld").runCommand("/fill -154 69 255 -154 74 276 barrier replace air");
    world.getDimension("Overworld").runCommand("/fill -182 69 255 -182 74 276 barrier replace air");
    mindKeeper.set(CURRENT_LEVEL, 0);
    world.sendMessage("currentlevel = " + mindKeeper.get(CURRENT_LEVEL));
  }
});

class ClonePos {
  point1: Vector3;
  point2: Vector3;

  constructor(point1: Vector3, point2: Vector3) {
    this.point1 = point1;
    this.point2 = point2;
  }
}

const gateFrames: ClonePos[] = [
  {
    point1: vector3(-226, 66, 223),
    point2: vector3(-219, 62, 223),
  },
  {
    point1: vector3(-226, 61, 223),
    point2: vector3(-219, 57, 223),
  },
  {
    point1: vector3(-226, 56, 223),
    point2: vector3(-219, 52, 223),
  },
  {
    point1: vector3(-226, 51, 223),
    point2: vector3(-219, 47, 223),
  },
  {
    point1: vector3(-226, 46, 223),
    point2: vector3(-219, 42, 223),
  },
];

let PlayGateOpenAnimation = async () => {
  playAnimation(gateFrames, frameDuration, false, gateRoot);
  if (mindKeeper.get(CURRENT_LEVEL) == 0) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
};

let ResetGate = () => SetFrame(gateFrames[0], gateRoot);

async function SetFrame(frame: ClonePos, destination: Vector3) {
  await world
    .getDimension("overworld")
    .runCommandAsync(
      `/clone ${Vector3ToCommandString(frame.point1)} ${Vector3ToCommandString(frame.point2)} ${Vector3ToCommandString(
        destination
      )}`
    );
}

let animationPlaying = false;
async function playAnimation(
  frames: ClonePos[],
  delayTime: number,
  reverse: boolean,
  destination: Vector3,
  force: boolean = false
) {
  if (animationPlaying && !force) {
    world.sendMessage("Animation already playing");
    return;
  }
  let frameCount = frames.length;
  if (!force) {
    animationPlaying = true;
  }

  for (let i = 0; i < frameCount; i++) {
    let frame = reverse ? frames[frameCount - i - 1] : frames[i];
    await world
      .getDimension("overworld")
      .runCommandAsync(
        `/clone ${Vector3ToCommandString(frame.point1)} ${Vector3ToCommandString(
          frame.point2
        )} ${Vector3ToCommandString(destination)}`
      );
    await delay(delayTime);
  }
  if (!force) {
    animationPlaying = false;
  }
}

triggerManager.RegisterFunctionTrigger("BottomTreeHouse", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 0) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

triggerManager.RegisterFunctionTrigger("PastLevel1", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 2) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

triggerManager.RegisterFunctionTrigger("PastLevel2", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 4) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

triggerManager.RegisterFunctionTrigger("PastLevel3", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 6) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

triggerManager.RegisterFunctionTrigger("PastLevel4", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 8) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

triggerManager.RegisterFunctionTrigger("CompletedTheMission", async (event) => {
  if (mindKeeper.get(CURRENT_LEVEL) == 10) {
    mindKeeper.increment(CURRENT_LEVEL);
  }
});

Commands.register(PREFIX, "info", (arg) => {
  world.sendMessage("-----------------");
  world.sendMessage("Current level: " + mindKeeper.get(CURRENT_LEVEL));
  world.sendMessage("Agent ID: " + mindKeeper.get(AGENT_ID));
  world.sendMessage("Engine Version: 1.0.2");
  world.sendMessage("Engine is running");
  world.sendMessage("Active players: " + world.getPlayers().length);
  world.sendMessage("Current dimension: " + arg.player.dimension.id);
  world.sendMessage("Current position: " + Vector3ToFancyString(arg.player.location));
  world.sendMessage("-----------------");
});

system.afterEvents.scriptEventReceive.subscribe((event) => {
  if (event.id == "cc:getId") {
    let id = event.message;
    world.sendMessage("Script got the id " + id);
    mindKeeper.set(AGENT_ID, id);
  }
});

system.afterEvents.scriptEventReceive.subscribe((event) => {
  if (event.id == "cc:getId") {
    let id = event.message;
    world.sendMessage("Script got the id " + id);
    mindKeeper.set(AGENT_ID, id);
  }
});

world.afterEvents.worldInitialize.subscribe(() => {
  mindKeeper.registerStore(CURRENT_LEVEL, StoreType.number);
  mindKeeper.registerStore(AGENT_ID, StoreType.string);
  triggerManager.RegisterStores();
  mindKeeper.registerToWorld();

  triggerManager.Load();
});

world.beforeEvents.itemUseOn.subscribe((event) => {
  trailMaker.OnItemUse(event);
  triggerManager.OnItemUse(event);
});