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 { MinecraftBlockTypes } from "./vanilla-data/mojang-block";
import { TransitionTrailToLevel1 } from "./trails/TransitionTrailToLevel1";
import { TransitionTrailToLevel2 } from "./trails/TransitionTrailToLevel2";
import { TransitionTrailToLevel3 } from "./trails/TransitionTrailToLevel3";

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 };

triggerManager.RegisterFunctionTrigger("resetPath", (event) => {
  resetLightPath();
});

async function resetLightPath() {
  world.getDimension("overworld").runCommand("/fill 2467 9 87 2468 9 105 air");
}

let isIntroToLevel1Sqeuence = false;
let isMakingLevel1 = false;
let isMakingLevel2 = false;
let isMakingLevel3 = false;
let isMakingLevel4 = false;

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

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

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

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

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:
        Pupeteer.setActionBar("Trigger1 works");
        if (!isMakingLevel1) {
          isMakingLevel1 = true;
          world.sendMessage("Starting level1");
          level1.update();
        }
        break;
      case 2:
        Pupeteer.setActionBar("Go to the next level.");
        transitionTrail1.spawnNext();
        break;
      case 3:
        Pupeteer.setActionBar("Trigger2 works");
        if (!isMakingLevel2) {
          isMakingLevel2 = true;
          world.sendMessage("Starting level2");
          level2.update();
        }
        break;
      case 4:
        Pupeteer.setActionBar("Trigger3 works");
        if (!isMakingLevel3) {
          isMakingLevel3 = true;
          world.sendMessage("Starting level3");
          level3.update();
        }
        break;
      case 5:
        Pupeteer.setActionBar("Trigger4 works");
        if (!isMakingLevel4) {
          isMakingLevel4 = true;
          world.sendMessage("Starting level4");
          level4.update();
        }
        break;
      case 6:
        break;
    }
  }
});

triggerManager.RegisterFunctionTrigger("lightPath", (event) => {
  lightUpPath();
});

async function lightUpPath() {
  let overworld: Dimension = world.getDimension("overworld");
  let pos1 = vector3(2467, 9, 87);
  let pos2 = vector3(2468, 9, 105);

  for (let z = pos2.z; z >= pos1.z; z--) {
    let volume: BlockVolume = new BlockVolume(vector3(pos1.x, pos1.y, z), vector3(pos1.x + 1, pos1.y, z));
    overworld.fillBlocks(volume, MinecraftBlockTypes.RedstoneBlock);
    await delay(4);
  }
}

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);
});

async function randomExplosions() {
  let pos1 = vector3(2465, 10, 82);
  let pos2 = vector3(2471, 18, 90);

  for (let i = 0; i < 5; i++) {
    let pos = vector3(
      pos1.x + Math.random() * (pos2.x - pos1.x),
      pos1.y + Math.random() * (pos2.y - pos1.y),
      pos1.z + Math.random() * (pos2.z - pos1.z)
    );

    system.run(() => {
      spawnParticle(pos, "minecraft:huge_explosion_emitter", new MolangVariableMap());
    });
  }
}

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");

    mindKeeper.set(CURRENT_LEVEL, 0);

    resetLightPath();

    level1.reset();
    level2.reset();
    level3.reset();
    level4.reset();

    isIntroToLevel1Sqeuence = false;
  }
});

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);
  }
});

class ClonePos {
  point1: Vector3;
  point2: Vector3;

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

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

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

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

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

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("-----------------");
});

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;
  }
}

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);
  }
});