import { Input, Plugin } from '@gedit/runtime-compiler';
import {
  isRectangle,
  isScene,
  isSprite,
  isText,
  isDragonBones,
  isFrames,
  isSpine,
  isTilemap,
  isCollisionBody,
  isGroup,
  isParticles,
} from '@gedit/runtime-render';
import * as generator from './genarate';
import { loadResource } from './load-resource';
import { config as printConfig } from './config';
import { scene as printScene } from './scene';
import { global } from './common';
import { inner } from './inner-func';

const prefixScene = (name: string | number) => `scene${name}`;
const prefixPreload = (name: string | number) => `preload${name}`;
const prefixCreate = (name: string | number) => `create${name}`;

export function phaserPlugin(): Plugin {
  const textureSet = new Set<string>();

  return {
    onInit(input: Input): void {
      console.log(input.scenes);
      console.log(this.ctx.meta);

      printConfig(this);
      this.println(`window.${global.GAME_INSTAMCE} = new ${global.ENGINE}.Game(${global.GAME_CONFIG});`);
      this.println(`window.${global.GAME_OBJECT_MAP} = new Map();`);

      // FIXME: @munong 只有有碰撞体和传感器的才需要这部分全局变量
      this.println(`window.${global.GAME_BODY_MAP} = new Map();`);
      this.println(`window.${global.GAME_BODY_FACTORY} = ${global.ENGINE}.Physics.Matter.Matter.Bodies;`);
      this.println(`window.${global.GAME_BODY} = ${global.ENGINE}.Physics.Matter.Matter.Body;`);

      inner(this);

      input.scenes.forEach((component, index) => {
        printScene(this, component, index);
      });
    },
    onCreate(component, parent, index): void {
      if (!component) {
        return;
      }

      if (isScene(component)) {
        const sceneName = prefixCreate(index);
        this.func(sceneName);
        return;
      }

      if (isSprite(component)) {
        const { sprite } = component;
        textureSet.add(sprite.texture);
        generator.sprite(this, component);
      }

      if (isText(component)) {
        generator.text(this, component);
      }

      if (isRectangle(component)) {
        generator.rect(this, component);
      }

      if (isDragonBones(component)) {
        const { dragonbones } = component;
        textureSet.add(dragonbones.texture);
        generator.dragonbones(this, component);
      }

      if (isFrames(component)) {
        generator.frames(this, component, textureSet);
      }

      if (isParticles(component)) {
        const { particles } = component;
        textureSet.add(particles.texture);
        generator.particles(this, component);
      }

      if (isSpine(component)) {
        const { spine } = component;
        textureSet.add(spine.texture);
        generator.spine(this, component);
      }

      if (isTilemap(component)) {
        const { tilemap } = component;
        textureSet.add(tilemap.texture);
        generator.tilemap(this, component);
      }

      if (isCollisionBody(component)) {
        generator.collisionBody(this, component, parent);
      }

      if (isGroup(component)) {
        generator.group(this, component);
      }
    },
    afterCreate(component, _, index): void {
      if (isScene(component)) {
        this.pop();

        this.func(prefixPreload(index));
        textureSet.forEach(texture => {
          loadResource(this, texture);
        });
        this.pop();

        textureSet.clear();
      }
    },
    onStart(): void {
      const { input, mainScene } = this.ctx;
      this.println('');
      this.comment('Game start!');
      input!.scenes.forEach((scene, index) => {
        this.println(`${global.GAME_INSTAMCE}.scene.add('${scene.name}', ${prefixScene(index)});`);
      });
      this.println(`${global.GAME_INSTAMCE}.scene.start('${mainScene}');`);
    },
  };
}