var Doors = function(game, maze, options)
{
    var self=this;

    this.mesh = [];
    this.pivots = [];
    this.pivots_refs = {};
    this.door_separators = [];
    this.outside_separators = [];

    var material;
    var depth;
    var depth2;
    var total_doors=0;

    this.cells = [];
    this.generated_doors = {};
    this.data_doors = {};

    this.load= function()
    {
        var self=this;

        depth = (Math.sqrt(3)/2) * game.opt.door_size*1.0;
        depth2 = (Math.sqrt(3)/2) * game.opt.door_size * Math.sqrt(3)/2 *1.35;

        var texloader = new THREE.TextureLoader();
        this.cubeTexture=texloader.load('textures/wall.jpg');
        this.cubeTexture.wireframe=true;
        this.cubeTexture.wrapS = this.cubeTexture.wrapT = THREE.RepeatWrapping;
        this.cubeTexture.repeat.set( 0.1, 0.1 );

        


        return new Promise(function(ok, reject)
        {
            var ended=0;
            var loader = new THREE.JSONLoader();
            loader.load( "js/meshes/door.js", function(geometry, mat)
            {
                self.door_geo = geometry;
                self.door_mat = mat;
                ended++;
                if(ended==2)
                {
                    ok();
                }
            });
            loader.load( "js/meshes/wall.js", function(geometry, mat)
            {
                self.wall_geo = geometry;
                self.wall_mat = mat;
                ended++;
                if(ended==2)
                {
                    ok();
                }
            });
        });
    };

    this.build = function()
    {
        var self=this;

        this.container = new THREE.Object3D();
        this.floor_geom = new THREE.Geometry();
        this.doors_geom = new THREE.Geometry();


        this.num_items_line = Math.floor(Math.sqrt(options.maze_num));

        var total=0;
        self.max_row = 0;
        self.max_line = 0;

        // Loop to create maze
        // Loop lines
        for(var row=0; (row<this.num_items_line || total < options.maze_num); row++)
        {
            self.max_row = row;
            for(var line=0; (line<this.num_items_line &&  total < options.maze_num); line++)
            {
                if(self.max_line<line) { self.max_line= line ; }
                total++;
                var cell =  self.create_cell({ x: row , y: 1, z:line });
                if(!self.generated_doors[row])
                {
                    self.generated_doors[row] = {};
                }
                self.generated_doors[row][line]  = cell;
                self.generated_doors[row][line].opened_doors=[];
            }
        }

        // Open/Close some doors
        this.maze_doors();

        // Loop to really the meshes
        // Loop lines
        total=0;
        for(var row=0; (row<this.num_items_line || total < options.maze_num); row++)
        {
            for(var line=0; (line<this.num_items_line &&  total < options.maze_num); line++)
            {
                self.create_meshes({num:total, real_x:row, x: row , y: 1, real_z : line, z:line });
                total++;
            }
        }

        var material = new THREE.MeshBasicMaterial( { color: 0x3366bb  } );
        var floor = new THREE.Mesh( this.floor_geom, material);
        this.container.add(floor);

        material = new THREE.MeshBasicMaterial( { color: 0x442233  } );
        console.log('mat ',this.wall_mat);
        var doors = new THREE.Mesh( this.doors_geom, new THREE.MultiMaterial(this.wall_mat));
        this.mesh = [ doors];
        this.container.add(doors);

        // Correct position of the maze depending on the start position and direction
        var move_x = this.start_x*depth2*2;
        var move_z = this.start_z*depth2*2;

        this.container.position.x = options.x - move_x;
        this.container.position.y = 0;
        this.container.position.z = options.z - move_z;

        game.scene.add( this.container );
    };


    this.get_random_start_end = function()
    {
        var start_on_x = !!Math.floor(Math.random()*2);
        var x=0;
        var z =-1;

        // Start pos
        while(!this.generated_doors[x] || !this.generated_doors[x][z])
        {
            z = Math.floor(Math.random()*(this.max_line+1));
        }

        this.start_x = x;
        this.start_z = z;
        this.start_door = this.generated_doors[x][z];
        z=-1;

        x= this.max_row;

        // End door
        while(!this.generated_doors[x] || !this.generated_doors[x][z] || (this.start_x===x && this.start_z===z))
        {
            z = Math.floor(Math.random()*(this.max_line+1));
        }

        this.end_x = x;
        this.end_z = z;
        this.end_door = this.generated_doors[x][z];
    };

    this.maze_doors = function()
    {
        this.get_random_start_end();


        // Start doors
        var params = { x: this.start_x , z: this.start_z, real_x:'outside',real_z:'outside'};
        var cell = this.cells[this.start_x*this.num_items_line + this.start_z];
        var start_door_top_bottom=false;

        this.start_i = 4;
        this.create_separation_line(cell,params, this.start_i, 'start');
        this.generated_doors[this.start_x][this.start_z].opened_doors.push(this.start_i);

        // End doors
        var params = { x: this.end_x , z: this.end_z, real_x:'outside',real_z:'outside'};
        var cell = this.cells[this.end_x*this.num_items_line + this.end_z];
        this.end_i = 1;
        this.create_separation_line(cell,params, this.end_i, 'end');
        this.generated_doors[this.end_x][this.end_z].opened_doors.push(this.end_i);

        this.maze_doors_next([Math.floor(Math.random()*(this.max_line-1)),Math.floor(Math.random()*(this.max_row-1))]);
    };

    this.maze_doors_next = function(opt)
    {
        var self=this;
        var initial_x = opt[0];
        var initial_z = opt[1];

        this.generated_doors[initial_x][initial_z].used=1;

        var next_doors_full = this.near_doors(initial_x, initial_z);
        var next_doors_unused=[];
        next_doors_full.forEach(function(door)
        {
            if(!self.generated_doors[door[0]][door[1]].used)
            {
                next_doors_unused.push(door);
            }
        });
        if(next_doors_unused.length>0)
        {
            var opened_link = Math.floor(Math.random()*next_doors_unused.length);
            var dest_x = next_doors_unused[opened_link][0];
            var dest_z = next_doors_unused[opened_link][1];

            // Fill generated_doors data
            // Same row
            if(initial_x ==dest_x)
            {
                // Bottom door
                if(initial_z<dest_z)
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(0);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(3);
                }
                else
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(3);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(0);
                }
            }
            else if(initial_x<dest_x)
            {
                var pair = !!(initial_x%2===0)
                if(initial_z==dest_z)
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(pair ? 1 : 2);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(pair ? 4 : 5);
                }
                else
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(pair ? 2 : 1);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(pair ? 5 : 4);
                }
            }
            else
            {
                var pair = !!(initial_x%2===0)
                if(initial_z==dest_z)
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(pair ? 5 : 4);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(pair ? 2 : 1);
                }
                else
                {
                    this.generated_doors[initial_x][initial_z].opened_doors.push(pair ? 4 :5);
                    this.generated_doors[dest_x][dest_z].opened_doors.push(pair ? 1 : 2);
                }
            }

            this.maze_doors_next(next_doors_unused[opened_link]);


            // DEBUG!
            // Create a visual line
            if(game.opt.debug_level>1)
            {
                // Visualize path
                var geometry = new THREE.BufferGeometry();
                var positions = new Float32Array( 2 * 3 ); // 3 vertices per point
                geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
                drawCount = 2; // draw the first 2 points, only
                geometry.setDrawRange( 0, drawCount );
                var ref = this.cells[initial_x*this.num_items_line + initial_z];
                var dest = this.cells[dest_x*this.num_items_line + dest_z];
                var material = new THREE.LineBasicMaterial( { color: Math.random() * 0xffff00 + 0x0000ff, linewidth: 2 } );
                line = new THREE.Line( geometry,  material );
                this.container.add( line );
                var positions = line.geometry.attributes.position.array;
                positions[0]=(ref.position.x);
                positions[1]=(1);
                positions[2]=(ref.position.z);
                positions[3]=(dest.position.x);
                positions[4]=(1);
                positions[5]=(dest.position.z);
            }
        }

        // Do a maze with the not connected dots too
        else
        {
            for(var x=0; x<=this.max_row; x++)
            {
                for(var z=0; z<=this.max_line; z++)
                {
                    // Need to link and unused cell with a used cell
                    if(this.generated_doors[x][z] && !this.generated_doors[x][z].used)
                    {
                        next_doors_full = this.near_doors(x, z);
                        next_doors_used=[];
                        next_doors_full.forEach(function(door)
                        {
                            if(self.generated_doors[door[0]][door[1]].used)
                            {
                                next_doors_used.push(door);
                            }
                        });
                        if(next_doors_used.length>0)
                        {
                            var connected_door = next_doors_used[Math.floor(Math.random()* next_doors_used.length)];
                            return this.maze_doors_next(connected_door);
                        }
                    }
                }
            }
        }
    };

    this.near_doors = function(initial_x, initial_z)
    {
        var self=this;
        var next_doors = [];

        var pair = !!(initial_x%2===0);
        var check = [];

        // top
        check.push([ initial_x, initial_z-1]);
        // bottom
        check.push([ initial_x, initial_z+1]);

        // left top
        check.push([ initial_x-1, pair ? initial_z-1 : initial_z ]);
        // left bottom
        check.push([ initial_x-1, pair ? initial_z : initial_z+1]);

        // right top
        check.push([ initial_x+1, pair ? initial_z-1 : initial_z]);
        // right bottom
        check.push([ initial_x+1, pair ? initial_z : initial_z+1]);

        check.forEach(function(c)
        {
            var x = c[0];
            var z = c[1];
            if(self.generated_doors[x] && self.generated_doors[x][z])
            {
                next_doors.push([x,z]);
            }
        });
        return next_doors;
    };

    /* Memorize the doors created, to avoid creating doble contiguous doors */
    this.register_door= function(x, z, i, cell)
    {
        if(!this.data_doors[x+'.'+z])
        {
            this.data_doors[x+'.'+z]={};
        }

        this.data_doors[x+'.'+z][i] = 1;
        var pair= x%2==0;

        if(cell)
        {
            switch(i)
            {
                case 0: this.register_door(x, z+1, 3, false); break;
                case 1: this.register_door(x+1, pair? z : z+1, 4, false); break;
                case 2: this.register_door(x+1, pair ? z-1 : z, 5, false); break;
            }
        }
    };

    this.get_pos = function(params)
    {
        var pair = params.x%2 ? depth2 : 0;
        var x =params.x * depth *2;
        var z =params.z * depth2 *2 + pair;

        return { x: x, z: z};
    };
    this.get_start_pos = function()
    {
        var coord = this.get_pos({ x: this.start_x , z: this.start_z });
        return { x: coord.x + options.x , z: coord.z + options.z };
    };
    this.get_end_pos = function()
    {
        var coord = this.get_pos({ x: this.end_x - this.start_x , z: this.end_z - this.start_z });
        return { x: coord.x + options.x , z: coord.z + options.z };
    };

    this.create_cell = function(params)
    {
        var self=this;

        this.fulldepth = game.opt.door_size + game.opt.door_size*2;
        var pair = params.x%2 ? depth2 : 0;
        var cell = new THREE.Object3D();
        cell.name='pos '+params.x+' / '+params.z;
        var pos = this.get_pos(params);
        cell.position.x=pos.x;
        cell.position.y=0;
        cell.position.z=pos.z;
        this.cells.push(cell);
        this.container.add(cell);

        // Create ground of that pivot
        var geom = new THREE.Geometry(); 
        var v1 = new THREE.Vector3(cell.position.x - game.opt.door_size/1.8 , 0 , cell.position.z-depth2*1.0 );
        var v2 = new THREE.Vector3(cell.position.x - game.opt.door_size*1.2 , 0,cell.position.z);
        var v3 = new THREE.Vector3(cell.position.x - game.opt.door_size/1.8 , 0 , cell.position.z+depth2*1.0 );

        var v4 = new THREE.Vector3(cell.position.x + game.opt.door_size/1.8 , 0 , cell.position.z+depth2*1.0 );
        var v5 = new THREE.Vector3(cell.position.x + game.opt.door_size*1.2 , 0,cell.position.z);
        var v6 = new THREE.Vector3(cell.position.x + game.opt.door_size/1.8 , 0 , cell.position.z-depth2*1.0 );

        var vcenter = new THREE.Vector3(cell.position.x ,1,cell.position.z);


        geom.vertices.push(vcenter);
        geom.vertices.push(v1);
        geom.vertices.push(v2);
        geom.vertices.push(v3);
        geom.vertices.push(v4);
        geom.vertices.push(v5);
        geom.vertices.push(v6);

        var material = new THREE.MeshBasicMaterial( { color: 0x3366bb  } );
        geom.faces.push( new THREE.Face3( 0, 1, 2 ) );
        geom.faces.push( new THREE.Face3( 0, 2, 3 ) );
        geom.faces.push( new THREE.Face3( 0, 3, 4 ) );
        geom.faces.push( new THREE.Face3( 0, 4, 5 ) );
        geom.faces.push( new THREE.Face3( 0, 5, 6 ) );
        geom.faces.push( new THREE.Face3( 0, 6, 1) );

        var object = new THREE.Mesh( geom, material);
        this.floor_geom.merge(object.geometry, object.matrix);
        //this.container.add(object);
        return cell;
    };

    this.get_pivot = function(cell, params, i)
    {
        var pivot = new THREE.Object3D();
        this.pivots.push(pivot);
        pivot.name ='p '+params.x+'/'+params.z+'/'+i;
        this.pivots_refs[params.x+'_'+params.z+'_'+i] = pivot;
        pivot.rotation.y= Math.radians(i*60);
        cell.add(pivot);

        return pivot;
    };

    this.create_meshes = function(params)
    {
        var self=this;


        this.fulldepth = game.opt.door_size + game.opt.door_size*2;
        var cell = this.cells[params.num];
        for(var i=0; i<6;i++)
        {
            if(!this.data_doors[params.x+'.'+params.z] || !this.data_doors[params.x+'.'+params.z][i])
            {
                this.register_door(params.x, params.z, i, cell);
                total_doors++;

                var pivot = this.get_pivot(cell, params, i);

                var materials = [];

                var mesh;
                if(this.generated_doors[params.real_x][params.real_z].opened_doors.indexOf(i)!==-1)
                {
                    //mesh = new THREE.Mesh( self.door_geo);
                    //pivot.add(mesh);
                    //this.mesh.push(mesh);
                }
                else
                {
                    mesh = new THREE.Mesh( self.wall_geo);
                    //pivot.add(mesh);
                    //this.mesh.push(mesh);
                    mesh.scale.x=game.opt.door_size;
                    mesh.scale.y= game.opt.door_size;
                    mesh.scale.z= game.opt.door_size;
                    mesh.rotation.y= Math.radians(i*60);

                    mesh.position.x = cell.position.x;
                    mesh.position.y = cell.position.y;
                    mesh.position.z = cell.position.z;
                    switch(i)
                    {
                        case 0:
                                mesh.position.z += game.opt.door_size;
                                break;
                        case 1: 
                                mesh.position.z += game.opt.door_size * 0.50;
                                mesh.position.x += depth;
                                break;
                        case 2:
                                mesh.position.z -= game.opt.door_size * 0.50;
                                mesh.position.x += depth;
                                break;
                        case 3:
                                mesh.position.z -= game.opt.door_size;
                                break;
                        case 4:
                                mesh.position.z -= game.opt.door_size * 0.50;
                                mesh.position.x -= depth;
                                break;
                        case 5:
                                mesh.position.z += game.opt.door_size * 0.50;
                                mesh.position.x -= depth;
                                break;
                    }
                    mesh.updateMatrix();

                    //this.container.add(mesh);
                    this.doors_geom.merge(mesh.geometry, mesh.matrix);

                    //mesh.position.set(0, 0, game.opt.door_size);

                    mesh.receiveShadow  = true;
                }
            }
            
            var areas=[];
            // Create collision items to detect enter in the cell
            if(this.generated_doors[params.real_x][params.real_z].opened_doors.indexOf(i)!==-1)
            {
                var door = this.generated_doors[params.real_x][params.real_z];
                var outside_door =
                    ( params.real_x == this.start_x && params.real_z == this.start_z && i == this.start_i) ||
                    ( params.real_x == this.end_x && params.real_z == this.end_z && i == this.end_i);

                this.create_separation_line(cell,params, i, false, outside_door);
            }
        }
        return cell;
    };

    this.create_separation_line= function(cell,params, i, extra_door, outside_door)
    {
        var geometry = new THREE.BufferGeometry();
        var positions = new Float32Array( 2 * 3 ); // 3 vertices per point
        geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
        drawCount = 2; // draw the first 2 points, only
        geometry.setDrawRange( 0, drawCount );


        var material = new THREE.LineBasicMaterial( { color: 0xffff00, linewidth: 2, transparent:true, opacity:0 } );
        if(game.opt.debug_level>1)
        {
            material = new THREE.LineBasicMaterial( { color: Math.random() * 0xffff00 + 0x0000ff, linewidth: 2 } );
        }
        var line = new THREE.Line( geometry,  material );

        var pivot = this.get_pivot(cell, params, i);
        pivot.add(line);

        var extra = extra_door ? game.opt.door_size*0.4 : 0;
        var positions = line.geometry.attributes.position.array;
        positions[0]=(depth*( !extra_door ? .5 : .7));
        positions[1]=(1);
        positions[2]=(game.opt.door_size*0.9 +extra);
        positions[3]=(-depth*(!extra_door ? .5 : .7));
        positions[4]=(1);
        positions[5]=(game.opt.door_size*0.9 +extra);

        line.name='l '+params.real_x+' / '+params.real_z;
        line.callback_data = {mazeid: maze.id, id:'cell_'+params.real_x+'_'+params.real_z, type:'change_cell', x: params.real_x, z:params.real_z};
        line.mazeid = maze.id;
        self.door_separators.push(line);
        if(extra_door=='start'){
            line.callback_data.action = 'leave_maze_from_start';
        }
        if(extra_door=='end'){
            line.callback_data.action = 'leave_maze_from_end';
        }
        if(outside_door)
        {
            self.outside_separators.push(line);
        }
    };

}