use na::{Mat4, one, Vec3};
use crate::mesh;
use blender;

use std::iter;

#[derive(Copy, Clone, Debug)]
#[allow(dead_code)]
pub enum MirrorFlags{
	Clipping = 1 << 0,
	MirrorU  = 1 << 1,
	MirrorV  = 1 << 2,
	AxisX    = 1 << 3,
	AxisY    = 1 << 4,
	AxisZ    = 1 << 5,
	VGroup   = 1 << 6,
	NoMerge  = 1 << 7,
}

#[derive(Copy, Clone, Debug)]
pub enum MirrorAxis{
    X = 0,
    Y = 1,
    Z = 2,
}

fn find_flip_group(vertex_groups: &[String], group_idx: i32) -> Option<i32>{
    let vertex_group = vertex_groups.get(group_idx as usize)?.clone();
    let separators = ['.', ' ', '-', '_'];
    let mirrored_group = if separators.contains(&vertex_group[vertex_group.len() - 2..].chars().next().unwrap()){
        let suffix = &vertex_group[vertex_group.len() - 1..];
        let mirror_suffix = match suffix{
            "l" => "r",
            "r" => "l",
            "L" => "R",
            "R" => "L",
            _ => return None,
        };
        vertex_group[0..vertex_group.len()-1].to_string() + mirror_suffix
    }else if separators.contains(&vertex_group[1..].chars().next().unwrap()){
        let suffix = &vertex_group[0..1];
        let mirror_suffix = match suffix{
            "l" => "r",
            "r" => "l",
            "L" => "R",
            "R" => "L",
            _ => return None,
        };
        mirror_suffix.to_string() + &vertex_group[1..]
    }else if vertex_group.len()>=4 && vertex_group[0..4].to_lowercase() == "left"{
        let rest = &vertex_group[4..];
        if vertex_group.starts_with("l"){
            "right".to_string() + rest
        }else if &vertex_group[1..2] == "E"{
            "RIGHT".to_string() + rest
        }else{
            "Right".to_string() + rest
        }
    }else if vertex_group.len()>=5 && vertex_group[0..5].to_lowercase() == "right"{
        let rest = &vertex_group[5..];
        if vertex_group.starts_with("r"){
            "left".to_string() + rest
        }else if &vertex_group[1..2] == "I"{
            "LEFT".to_string() + rest
        }else{
            "Left".to_string() + rest
        }
    }else{
        return None;
    };
    vertex_groups.iter().position(|name| mirrored_group == *name).map(|pos| pos as i32)
}

pub fn mirror_mesh(mirror: &blender::Object, object: &blender::Object, mesh: &mut mesh::Mesh, vertex_groups: &[String], axis: MirrorAxis){
    let flag: u16 = *mirror.get("flag").unwrap();
    let tolerance: f32 = *mirror.get("tolerance").unwrap();
    let tolerance_sq = tolerance * tolerance;

    // Calculate the matrix to invert the vertices
    let mut mirror_mat: Mat4<f32> = one();
    mirror_mat[(axis as usize, axis as usize)] = -1.0;
    if let Ok(mirror_ob) = mirror.get_object("mirror_ob"){
        let mirror_obj_mat: &Mat4<f32> = mirror_ob.get("obmat").unwrap();
        let object_mat: &Mat4<f32> = object.get("obmat").unwrap();
        let tmp = mirror_obj_mat.try_inverse().unwrap() * *object_mat;
        let itmp = tmp.try_inverse().unwrap();
        mirror_mat = itmp * mirror_mat * tmp;
    }

    let num_verts = mesh.mvert.len();
    let num_edges = mesh.medge.len();
    let num_loops = mesh.mloop.len();

    // Mirror the vertices
    let mirror_verts: Vec<mesh::MVert> = mesh.mvert.iter_mut().map(|v| {
        let mirror_v = (mirror_mat * vec4!(v.position, 1.0)).xyz();
        let l = (mirror_v - v.position).norm();
        if flag & MirrorFlags::NoMerge as u16 == 0 && l*l < tolerance_sq{
            let merge_v = (v.position + mirror_v) * 0.5;
            v.position = merge_v;
            *v
        }else{
            let mut v = *v;
            v.position = mirror_v;
            v
        }
    }).collect();
    mesh.mvert.extend_from_slice(&mirror_verts);

    // Mirror the edges
    let edges_clone = mesh.medge.clone();
    let mirror_edges = edges_clone.iter().map(|edge|{
        let mut mirror_edge = *edge;
        mirror_edge.v1 += num_verts as u32;
        mirror_edge.v2 += num_verts as u32;
        mirror_edge
    });
    mesh.medge.extend(mirror_edges);

    // Mirror the uv loops
    let uvs_clone = mesh.mloopuv.clone();
    mesh.mloopuv.extend_from_slice(&uvs_clone);

    // Mirror the loops, change the cw by using the
    // first vertex and then iterating the loop in reverse
    {
        let loops_clone = mesh.mloop.clone();
        let mirror_loops = mesh.mpoly.iter().flat_map(|poly| {
            let start = poly.loopstart;
            let end = poly.loopstart + poly.totloop;
            iter::once(start).chain((start+1..end).rev()).map(|i|{
                let mut mirror_loop = loops_clone[i as usize];
                mirror_loop.v += num_verts as u32;
                mirror_loop.e += num_edges as u32;
                mirror_loop
            })
        });
        mesh.mloop.extend(mirror_loops);
    }

    // Mirror the polygons
    let polys_clone = mesh.mpoly.clone();
    let mirror_polys = polys_clone.iter().map(|poly|{
        let mut mirror_poly = *poly;
        mirror_poly.loopstart += num_loops as u32;
        mirror_poly
    });
    mesh.mpoly.extend(mirror_polys);

    // Mirror the weights
    if flag & MirrorFlags::VGroup as u16 == 0{
        let dvert = mesh.dvert.clone();
		mesh.dvert.extend_from_slice(&dvert);
    }else{
		let current_dvert_len = mesh.dvert.len();
        for i in 0..current_dvert_len{
            //let mut weights = weights.clone();
            let dw = mesh.dvert(i).iter().map(|weight|{
                let mut weight = *weight;
                match find_flip_group(vertex_groups, weight.def_nr){
                    Some(mirror_group) => {
                        weight.def_nr = mirror_group;
                    }
                    None => {},
                }
                weight
            }).collect::<Vec<_>>();
			let dw_start = mesh.dweights.len();
			mesh.dweights.extend_from_slice(&dw);
			let dw_end = mesh.dweights.len();
			let flag = mesh.dvert[i].flag;
			mesh.dvert.push(mesh::MDeformVert{
				dw_start,
				dw_end,
				flag: flag,
			});
    	}
    }
    //mesh.dvert.extend_from_slice(&mirror_weights);

    mesh.recalculate_normals();
}

pub fn array_mesh(modifier: &blender::Object, mesh: &mut mesh::Mesh){
    let offset: Vec3 = *modifier.get("offset").unwrap();
    let count: u32 = *modifier.get("count").unwrap();
    // let scale: Vec3 = *modifier.get("scale").unwrap();
    // let length: f32 = *modifier.get("length").unwrap();
    // let merge_dist: f32 = *modifier.get("merge_dist").unwrap();
    // let fit_type: i32 = *modifier.get("fit_type").unwrap();
    // let offset_type: i32 = *modifier.get("offset_type").unwrap();
    // let flags: i32 = *modifier.get("flags").unwrap();
    // let dimensions = mesh.dimensions();

    // println!("Array modifer: offset: {}, scale: {}, length: {}, count: {}, offset_type: {}, fit_type: {}, flags: {}",
    //     offset,
    //     scale,
    //     length,
    //     count,
    //     offset_type,
    //     fit_type,
    //     flags);

    let num_verts = mesh.mvert.len() as u32;
    let num_edges = mesh.medge.len() as u32;
    let num_loops = mesh.mloop.len() as u32;

	// let min = mesh.mvert.iter().fold(mesh.mvert[0].position.x, |v1, v2| v1.min(v2.position.x));
	// let max = mesh.mvert.iter().fold(mesh.mvert[0].position.x, |v1, v2| v1.max(v2.position.x));

    let mvert = (0..count).flat_map(|i|{
        mesh.mvert.iter().map(move |v|{
            let mut v2 = v.clone();
            v2.position += offset * i as f32;
            // v2.position += scale.component_mul(&dimensions) * i as f32;
            v2
        })
    }).collect();

    // Duplicate edges
    let edges_clone = mesh.medge.clone();
    let edges =  (0..count).flat_map(|i|{
        edges_clone.iter().map(move |edge|{
            let mut mirror_edge = *edge;
            mirror_edge.v1 += num_verts * i;
            mirror_edge.v2 += num_verts * i;
            mirror_edge
        })
    }).collect();


    // Duplicate the uv loops
    let uvs = (0..count).flat_map(|_|{
        mesh.mloopuv.clone()
    }).collect();

    // Duplicate the loops, change the cw by using the
    // first vertex and then iterating the loop in reverse
    let poly_clone = mesh.mpoly.clone();
    let loops_clone = mesh.mloop.clone();
    let loops = (0..count).flat_map(|j|{
        let loops_clone = loops_clone.clone();
        poly_clone.clone().into_iter().flat_map(move |poly| {
            let loopstart = poly.loopstart;
            let totloop = poly.totloop;
            let loops_clone = loops_clone.clone();
            (loopstart..loopstart+1).chain((loopstart+1..loopstart+totloop).rev()).map(move |i|{
                let mut mirror_loop = loops_clone[i as usize];
                mirror_loop.v += num_verts * j;
                mirror_loop.e += num_edges * j;
                mirror_loop
            })
        })
    }).collect();

    // Duplicate the polygons
    let polys_clone = mesh.mpoly.clone();
    let polys = (0..count).flat_map(|i|{
        polys_clone.iter().map(move |poly|{
            let mut mirror_poly = *poly;
            mirror_poly.loopstart += num_loops as u32 * i;
            mirror_poly
        })
    }).collect();


    // Duplicate the weights
    let weights = (0..count).flat_map(|_i|{
        mesh.dvert.iter().map(|weights|{
            weights.clone()
        })
    }).collect();
    mesh.mvert = mvert;
    mesh.medge = edges;
    mesh.mloopuv = uvs;
    mesh.mloop = loops;
    mesh.mpoly = polys;
    mesh.dvert = weights;

}

#[allow(dead_code)]
pub enum SubsurfModifierFlag{
	Incremental  = 1 << 0,
	DebugIncr    = 1 << 1,
	ControlEdges = 1 << 2,
	SubsurfUv    = 1 << 3,
}