pub struct Block {
    id: i8,
    block_type:i8,
    block_rotation:f64,
    block_verts:[[f64;2];3],
    block_pos:[f64;2],
    side1_id:i8,
    side2_id:i8,
    side3_id:i8
}



// position, rotation, type
fn get_next_blocks_from_type( block_seq_array: &mut Vec<Block>, return_blocks:&mut Vec<Block>) {
    if !block_seq_array.is_empty() {
        let mut last_block_id:i8 = 0;
        let mut in_block_size:f64 = 1f64;
        let mut x:f64 = 0f64;
        let mut y:f64 = 0f64;
        let mut last_block_rotation:f64 = 0f64;
        let mut last_block_type:i8 = 0;
        let mut last_block_side1_id:i8 = 0;
        let mut last_block_side2_id:i8 = 0;
        let mut last_block_side3_id:i8 = 0;

        if let Some(last_block) = return_blocks.last_mut() {
            last_block_id = last_block.id;
            in_block_size = 1f64;
            x = last_block.block_pos[0];
            y = last_block.block_pos[1];
            last_block_rotation = last_block.block_rotation;
            last_block_type = last_block.block_type;

            if last_block_rotation == 0f64{
                last_block.block_verts = [[in_block_size+x, 0f64+y],[-in_block_size+x, 0f64+y],[0f64+x, in_block_size+y]];
            } else if last_block_rotation == 90f64{
                last_block.block_verts = [[0f64+x, -in_block_size+y],[0f64+x, in_block_size+y],[-in_block_size+x, 0f64+y]];
            }
            else if last_block_rotation== 180f64{
                last_block.block_verts = [[in_block_size+x, in_block_size+y],[-in_block_size+x, in_block_size+y],[0f64+x, 0f64+y]];
            }
            else if last_block_rotation == 270f64{
                last_block.block_verts = [[-in_block_size+x, -in_block_size+y],[-in_block_size+x, in_block_size+y],[0f64+x, 0f64+y]];
            }

        }
        if last_block_id != 0{

            let mut side1 = false;
            let mut side2 = false;
            let mut side3 = false;

            if last_block_type == 1 {
                side1=true;
            };
            if last_block_type == 2 {
                side2=true;
            };
            if last_block_type == 3 {
                side3=true;
            };
            if last_block_type == 4 {
                side1=true;
                side2=true;
            };
            if last_block_type == 5 {
                side2=true;
                side3=true;
            };
            if last_block_type == 6 {
                side1=true;
                side3=true;
            };
            if last_block_type == 7 {
                side1=true;
                side2=true;
                side3=true;
            };


            for blc in return_blocks.iter_mut() {
                if blc.id == last_block_id {
                    last_block_side1_id = blc.side1_id;
                }
            }
            if side1 && last_block_side1_id == 0 {
                let mut new_block_list:Vec<Block> = block_seq_array.drain(0..1).collect();
                if let Some(mut new_block) = new_block_list.pop() {
                    new_block.block_rotation = last_block_rotation + 180f64;
                    if new_block.block_rotation >= 360f64 {
                        new_block.block_rotation = new_block.block_rotation - 360f64;
                    }
                    if new_block.block_rotation < 0f64 {
                        new_block.block_rotation = new_block.block_rotation + 360f64;
                    }

                    if last_block_rotation == 0f64 {
                        new_block.block_pos[1] = y - in_block_size;
                    }
                    if last_block_rotation == 90f64 {
                        new_block.block_pos[0] = x + in_block_size;
                    }
                    if last_block_rotation == 180f64 {
                        new_block.block_pos[1] = y + in_block_size;
                    }
                    if last_block_rotation == 270f64 {
                        new_block.block_pos[0] = x - in_block_size;
                    }
                    let new_id = new_block.id;
                    for blc in return_blocks.iter_mut() {
                        if blc.id == last_block_id {
                            blc.side1_id = new_id;
                        }
                    }
                    new_block.side1_id = last_block_id;
                    return_blocks.push(new_block);
                    get_next_blocks_from_type ( block_seq_array, return_blocks);
                }
            }

            for blc in return_blocks.iter_mut() {
                if blc.id == last_block_id {
                    last_block_side2_id = blc.side2_id;
                }
            }
            if side2 && last_block_side2_id == 0  {
                let mut new_block_list:Vec<Block> = block_seq_array.drain(0..1).collect();
                if let Some(mut new_block) = new_block_list.pop() {
                    new_block.block_rotation = last_block_rotation + 90f64;
                    if new_block.block_rotation >= 360f64 {
                        new_block.block_rotation = new_block.block_rotation - 360f64;
                    }
                    if new_block.block_rotation < 0f64 {
                        new_block.block_rotation = new_block.block_rotation + 360f64;
                    }

                    if new_block.block_rotation == 0f64 {
                        new_block.block_pos[1] = y - in_block_size;
                    }
                    if new_block.block_rotation == 90f64 {
                        new_block.block_pos[0] = x + in_block_size;
                        new_block.block_pos[1] = y + in_block_size;
                    }
                    if new_block.block_rotation == 180f64 {
                        new_block.block_pos[0] = x - in_block_size;
                    }
                    let new_id = new_block.id;
                    for blc in return_blocks.iter_mut() {
                        if blc.id == last_block_id {
                            blc.side2_id = new_id;
                        }
                    }
                    new_block.side3_id = last_block_id;
                    return_blocks.push(new_block);
                    get_next_blocks_from_type ( block_seq_array, return_blocks);
                }
            }

            for blc in return_blocks.iter_mut() {
                if blc.id == last_block_id {
                    last_block_side3_id = blc.side3_id;
                }
            }
            if side3 && last_block_side3_id == 0  {
                let mut new_block_list:Vec<Block> = block_seq_array.drain(0..1).collect();
                if let Some(mut new_block) = new_block_list.pop() {
                    new_block.block_rotation = last_block_rotation - 90f64;
                    if new_block.block_rotation >= 360f64 {
                        new_block.block_rotation = new_block.block_rotation - 360f64;
                    }
                    if new_block.block_rotation < 0f64 {
                        new_block.block_rotation = new_block.block_rotation + 360f64;
                    }

                    if new_block.block_rotation == 0f64 {
                        new_block.block_pos[1] = y - in_block_size;
                        new_block.block_pos[0] = x - in_block_size;
                    }
                    if new_block.block_rotation == 90f64 {
                        new_block.block_pos[0] = x + in_block_size;
                    }
                    if new_block.block_rotation == 270f64 {
                        new_block.block_pos[1] = y + in_block_size;
                    }
                    let new_id = new_block.id;
                    for blc in return_blocks.iter_mut() {
                        if blc.id == last_block_id {
                            blc.side3_id = new_id;
                        }
                    }
                    new_block.side2_id = last_block_id;
                    return_blocks.push(new_block);
                    get_next_blocks_from_type ( block_seq_array, return_blocks );
                }
            }

        }


    }


}


fn main() {

    let mut return_blocks: Vec<Block> = vec![]; //allBlocks
    //vec![5,2,4,5,4,5,2,4,3,8,8,8,4,5,2,4,5,2,4,5,2,4,5,2,2,8,8,8,8,8,8,8,8,1,5,2,4,2,8,8,8,8,8,8];
    let mut block_type_seq_array: Vec<i8> = vec![5,2,4,5,4,5,2,4,3,8,8,8,4,5,2,4,5,2,4,5,2,4,5,2,2,8,8,8,8,8,8,8,8,1,5,2,4,2,8,8,8,8,8,8];
    let mut block_seq_array: Vec<Block> = vec![];
    let mut block_id:i8 = 0;
    for i in 0..block_type_seq_array.len() {
        block_id = block_id + 1;
        let new_block_type: Vec<_> = block_type_seq_array.drain(0..1).collect();
        let new_block_type = new_block_type[0] as i8;
        block_seq_array.push(
            Block {
            id: block_id,
            block_type:new_block_type,
            block_rotation:0f64,
            block_verts:[[0f64,0f64],[0f64,0f64],[0f64,0f64]],
            block_pos:[0f64,0f64],
            side1_id:0,
            side2_id:0,
            side3_id:0
        })
    }

    let mut new_block_list:Vec<Block> = block_seq_array.drain(0..1).collect();
    if let Some(new_block) = new_block_list.pop() {
        return_blocks.push(new_block);
        get_next_blocks_from_type ( &mut block_seq_array, &mut return_blocks );
    }



    for i in 0..return_blocks.len() {
        println!("return - id:{}, type:{}, verts:[[{},{}],[{},{}],[{},{}]], pos:[{},{}], s:{}, s:{}, s:{} , r:{}",
             return_blocks[i].id, return_blocks[i].block_type
            , return_blocks[i].block_verts[0][0], return_blocks[i].block_verts[0][1]
            , return_blocks[i].block_verts[1][0], return_blocks[i].block_verts[1][1]
            , return_blocks[i].block_verts[2][0], return_blocks[i].block_verts[2][1]
            , return_blocks[i].block_pos[0]
            , return_blocks[i].block_pos[1]
            , return_blocks[i].side1_id
            , return_blocks[i].side2_id
            , return_blocks[i].side3_id
            , return_blocks[i].block_rotation
            );
    }

    for i in 0..block_seq_array.len() {
        println!("left over - {}, {}, [[{},{}],[{},{}],[{},{}]]",
            block_seq_array[i].id, block_seq_array[i].block_type
            , block_seq_array[i].block_verts[0][0], block_seq_array[i].block_verts[0][1]
            , block_seq_array[i].block_verts[1][0], block_seq_array[i].block_verts[1][1]
            , block_seq_array[i].block_verts[2][0], block_seq_array[i].block_verts[2][1]
            );
    }

}