<template>
  <div id="scene" class="scene" :class="isSelection && 'scene--selection'" />
</template>

<script lang="ts">
// ...

// Types
import type { ISelf } from '@/models/modules';
// ...

export default defineComponent({
  name: 'Scene',

  setup() {
    const store = useStore(key);

    // Core

    let container: HTMLElement;

    let camera: PerspectiveCamera = new THREE.PerspectiveCamera();
    let listener: AudioListener = new THREE.AudioListener();

    let scene: Scene = new THREE.Scene();

    let renderer: WebGLRenderer = new THREE.WebGLRenderer({
      antialias: true,
    });

    // Helpers
    let helper: Helper = new Helper();
    let assets: Assets = new Assets();
    let events: Events = new Events();
    let audio: AudioBus = new AudioBus();

    // Modules
    let world = new World();

   // Functions
    let init: () => void;
    let animate: () => void;
    let render: () => void;
    let onWindowResize: () => void;
    // ...

    // Store getters
    const isPause = computed(() => store.getters['layout/isPause']);
    // ..
    
    // ...

    // Go!
    init = () => {
      // Core
      container = document.getElementById('scene') as HTMLElement;

      // ...

      // Listeners
      window.addEventListener('resize', onWindowResize, false);
      // ...

      // Modules
      assets.init(self);
      audio.init(self);
      world.init(self);

      // First render
      onWindowResize();
      render();
    };

    // ...

    animate = () => {
      if (!isPause.value) {
        world.animate(self);

        render();
      }

      // ...

      requestAnimationFrame(animate);
    };

    onWindowResize = () => {
      camera.aspect = window.innerWidth / window.innerHeight;
      camera.updateProjectionMatrix();

      renderer.setSize(window.innerWidth, window.innerHeight);
    };


    render = () => {
      renderer.render(scene, camera);
      // console.log('Renderer info: ', renderer.info.memory.geometries, renderer.info.memory.textures, renderer.info.render);

      // ...
    };

    // This is self )
    let self: ISelf = {
      // Utils
      helper,
      assets,
      events,
      audio,

      // Core
      store,
      scene,
      listener,
      render,
    };

    // ...

    onMounted(() => {
      init();
      animate();
    });

    // ...
  },
});
</script>

// Interfaces
///////////////////////////////////////////////////////

// Статичный модуль без копий - например Атмосфера
export interface ISimpleModule {
 init(self: ISelf): void;
}

// Модули
interface IModule extends ISimpleModule {
 isCanAdd(self: ISelf, vector: Vector3, name?: Names): boolean;
 add(self: ISelf, vector: Vector3, name?: Names): void;
 remove(self: ISelf, items: string[], name?: Names): void;
}

// Aнимированные модули
interface IAnimatedModule extends IModule {
 animate(self: ISelf): void;
}

// Модули с копиями
interface IModules extends IModule {
 initItem(self: ISelf, item: TObject, isStart: boolean): void;
}

// Анимированные модули с копиями
interface IAnimatedModules extends IAnimatedModule {
 initItem(self: ISelf, item: TObject, isStart: boolean): void;
}

// Abstract
///////////////////////////////////////////////////////

// Статичный модуль без копий - например Атмосфера
export abstract class SimpleModule implements ISimpleModule {
 constructor(public name: Names) {
   this.name = name;
 }

 // Инициализация
 public abstract init(self: ISelf): void;
}

// Обертки и модули
abstract class Module extends SimpleModule implements IModule {
 constructor(public name: Names) {
   super(name);
 }

 // Можно ли добавить новый объект?
 public abstract isCanAdd(self: ISelf, vector: Vector3, name?: Names): boolean;

 // Добавить новую единицу
 public abstract add(self: ISelf, vector: Vector3, name?: Names): void;

 // Убрать объекты
 public abstract remove(self: ISelf, items: string[], name?: Names): void;
}

// Анимированный модуль
export abstract class AnimatedModule extends Module implements IAnimatedModule {
 constructor(public name: Names) {
   super(name);
 }

 // Анимация
 public abstract animate(self: ISelf): void;
}

//  Модули
abstract class Modules extends Module implements IModules {
 constructor(public name: Names) {
   super(name);
 }

 // Инициализировать новую единицу
 public abstract initItem(self: ISelf, item: TObject, isStart: boolean): void;
}

// Анимированные модули
abstract class AnimatedModules extends Modules implements IAnimatedModules {
 constructor(public name: Names) {
   super(name);
 }

 // Анимация
 public abstract animate(self: ISelf): void;
}

// Real
///////////////////////////////////////////////////////

// Обертки
export class Wrapper extends AnimatedModule implements IAnimatedModule {
 constructor(public name: Names) {
   super(name);
 }

 // Инициализация
 public init(self: ISelf): void {
   console.log('modules.ts', 'Wrapper', 'init ', this.name, self);
 }

 // Можно ли добавить новый объект?
 public isCanAdd(self: ISelf, vector: Vector3, name?: Names): boolean {
   console.log('modules.ts', 'Wrapper', 'isCanAdd ', vector, name);
   return false;
 }

 // Добавить объект
 public add(self: ISelf, vector: Vector3, name?: Names): void {
   console.log('modules.ts', 'Wrapper', 'add ', vector, name);
 }

 // Удалить объекты
 public remove(self: ISelf, items: string[], name?: Names): void {
   console.log('modules.ts', 'Wrapper', 'remove ', items, name);
 }

 // Анимация
 public animate(self: ISelf): void {
   console.log('modules.ts', 'Wrapper', 'animate ', this.name, self);
 }
}

// Строения
export class Builds extends Modules implements IModules {
 constructor(public name: Names) {
   super(name);
 }

 // Инициализация
 public init(self: ISelf): void {
   console.log('modules.ts', 'Builds', 'init ', this.name, self);
 }

 // Инициализация одного объекта
 public initItem(self: ISelf, item: TObject, isStart: boolean): void {
   console.log(
     'modules.ts',
     'Builds',
     'initItem ',
     this.name,
     self,
     item,
     isStart,
   );
 }

 // Можно ли добавить новый объект?
 public isCanAdd(self: ISelf, vector: Vector3): boolean {
   return self.helper.isCanAddItemHelper(self, vector, this.name);
 }

 // Удалить объекты
 public remove(self: ISelf, items: string[]): void {
   self.helper.sellHelper(self, items, this.name);
 }

 // Добавить объект
 public add(self: ISelf, vector: Vector3): void {
   self.helper.addItemHelper(self, this, vector);
 }
}

export class StaticSimpleBuilds extends Builds {
 public geometry!: BoxBufferGeometry;
 public material!: MeshStandardMaterial;

 constructor(public name: Names) {
   super(name);
 }

 // Инициализация одного объекта
 public initItem(self: ISelf, item: TObject, isStart: boolean): void {
   self.helper.initItemHelper(
     self,
     this.name,
     this.geometry,
     this.material,
     item,
     isStart,
   );
 }

 public init(self: ISelf): void {
   // Форма
   this.geometry = getGeometryByName(this.name);

   // Материал
   this.material = new THREE.MeshStandardMaterial({
     color: Colors[this.name as keyof typeof Colors],
     map: self.assets.getTexture(this.name), // Текстура
   });

   // Инициализация
   self.helper.initModulesHelper(self, this);
 }
}

export class StaticModelsBuilds extends Builds {
 public model!: GLTF;

 constructor(public name: Names) {
   super(name);
 }

 // Инициализация одного объекта
 public initItem(self: ISelf, item: TObject, isStart: boolean): void {
   self.helper.initItemFromModelHelper(
     self,
     this.name,
     this.model,
     item,
     isStart,
   );
 }

 public init(self: ISelf): void {
   // Модель
   self.assets.GLTFLoader.load(
     `./images/models/${this.name}.glb`,
     (model: GLTF) => {
       // Прелоадер
       self.helper.loaderDispatchHelper(self.store, `${this.name}IsLoaded`);
       this.model = self.helper.traverseHelper(self, model, this.name);

       // Инициализация
       self.helper.initModulesHelper(self, this);
       self.render();
     },
   );
 }
}

// ...

this._positions = [];
if (self.store.getters['objects/isStart']) {
 this._objects = [];

 // Генерируем горы заново
 for (let n = 0; n < DESIGN.ATMOSPHERE_ELEMENTS[Names.stones]; ++n) {
   this._meshes = new THREE.Group();

   this._position = getUniqueRandomPosition(
     this._positions,
     0,
     0,
     10,
     DESIGN.SIZE / DESIGN.CELL / 12.5,
     false,
   );
   this._positions.push(this._position);

   // ...

   this._objects.push({
     name: Names.stones,
     id: '',
     data: this._object,
   });

   self.scene.add(this._meshes);
 }

 // Сохраняем в хранилище
 self.store.dispatch('objects/saveObjects', {
   name: Names.stones,
   objects: this._objects,
 });
} else {
 // Восстанавливаем горы из хранилища
 this._objects = [...self.store.getters['objects/objects'][Names.stones]];

 this._objects.forEach((group) => {
   this._meshes = new THREE.Group();

   group.data.forEach((stone: TStone) => {
     this._position = { x: stone.x, z: stone.z };
     this._height = stone.h;

     self.helper.geometry = new THREE.BoxBufferGeometry(
       DESIGN.CELL,
       DESIGN.CELL * this._height,
       DESIGN.CELL,
     );

     this._mesh = new THREE.Mesh(
       self.helper.geometry,
       self.helper.material,
     );
     this._mesh.position.set(
       this._position.x * DESIGN.CELL,
       OBJECTS.sand.positionY,
       this._position.z * DESIGN.CELL,
     );
     this._mesh.name = Names.stones;

     this._meshes.add(this._mesh);
   });
   self.scene.add(this._meshes);
 });
}

// ...