import * as bjs from 'babylonjs';

import {
    Scene
} from '../../scene'

import {
    generateWaterMaterial
} from '../../utils'
import { WaterFloor } from '../../elements/waterfloor';
import { ExchangeOrder } from '../../../market/orderupdate';
import { Queue } from 'queue-typescript';
import { SceneElement } from '../../sceneelement';
import { runInThisContext } from 'vm';

export class ExchangeOrderSceneElement extends SceneElement
{
    constructor(public name:string, public x: number, public y: number, public z: number, scene:Scene, public order: ExchangeOrder )
    {
        super(name,x,y,z,scene);
    }
}

export class SimpleOrderBlock extends ExchangeOrderSceneElement
{
    block:bjs.Mesh;
    blockTexture:bjs.DynamicTexture;
    blockMaterial:bjs.StandardMaterial;


    constructor(name:string, public x: number, public y: number, public z: number, scene:Scene, public order: ExchangeOrder)
    {
        super(name, x, y, z, scene, order);
        this.create();
    }

    protected create()
    {
        console.log("Creating SimpleOrder BlocK");
        this.block = bjs.MeshBuilder.CreateBox("box", {height: 100.0, width: 100.0, depth: 100.0}, this.scene.bjsScene);
        this.block.parent = this;
        this.blockTexture = new bjs.DynamicTexture(name, {width:256, height:128}, this.scene.bjsScene, true);
        this.blockTexture.hasAlpha = true;
        this.blockMaterial = new bjs.StandardMaterial("SpreadLabel", this.scene.bjsScene);
        this.blockMaterial.diffuseTexture = this.blockTexture;
        this.block.material = this.blockMaterial;
    }

    protected onRender()
    {
        console.log("Order block render");
    }
}

export class ExchangeOrderVisualizer extends SceneElement
{
   ExchangeOrders : Map<number,ExchangeOrderSceneElement> = new Map<number, ExchangeOrderSceneElement>();

   processOrderUpdate(order : ExchangeOrder)
   {
       if (! this.ExchangeOrders.has(order.id))
       {
           console.log("Creating Order Element");
           //first time we've gotten an update
           //create the Exchange Order Scene Element
           let orderElement:ExchangeOrderSceneElement = this.createOrderElement(order);
           this.ExchangeOrders[order.id] = orderElement;
           this.addChild(orderElement);
       }

   }

   protected createOrderElement(order : ExchangeOrder) : ExchangeOrderSceneElement
   {
        return null;
   }
}

export class SimpleBlockOrderVisualizer extends ExchangeOrderVisualizer
{
    protected createOrderElement(order : ExchangeOrder)
    {
        console.log("Factory : SimpleOrder BlocK");
        return new SimpleOrderBlock("order",0,0,0,this.scene, order);
    }

}

export class TradingRigManagerScene extends Scene
{
    water : WaterFloor;
    orderUpdateQueue : Queue<ExchangeOrder> = new Queue<ExchangeOrder>();

    orderVisualizer : ExchangeOrderVisualizer;

    protected async createScene()
    {
          //Water Floor
        this.water = new WaterFloor("water",0,0,0,this);
        this.AddSceneElement(this.water);

        this.orderVisualizer = new SimpleBlockOrderVisualizer("order visualizer",0,0,0,this);
        this.AddSceneElement(this.orderVisualizer);
    }

    protected onPreRender()
    {

        while(this.orderUpdateQueue.length > 0)
        {
            console.log('Popping Order off the queue...');
            let orderUpdate:ExchangeOrder = this.orderUpdateQueue.dequeue();
            this.orderVisualizer.processOrderUpdate(orderUpdate);
        }
    }
}