use std::collections::HashMap;
use std::fs::read_to_string;
use std::io::Error as IoError;
use std::path::{Path, PathBuf};

use crate::material::Material;
use crate::mesh::Mesh;
use crate::opengl::shader::{
    Error as ShaderError,
    Kind as ShaderKind,
    Program as ShaderProgram,
    Shader,
};
use crate::shader_preprocessor::{Error as ShaderPreprocessorError, ShaderPreprocessor};
use crate::texture::{Id as TextureId, Texture};
use crate::transform::Transform;
use crate::vector::Vec3;
use crate::vertex::Vertex;

const SHADER_DIR: &str = "engine";

const VERTEX_SHADER_FILE: &str = "vertex.glsl";
const FRAGMENT_SHADER_FILE: &str = "fragment.glsl";

#[derive(Debug)]
pub struct Object
{
    id: Id,
    mesh: Mesh,
    shader: ShaderProgram,
    transform: Transform,
    textures: HashMap<TextureId, Texture>,
    material: Material,
}

impl Object
{
    /// Returns the object ID.
    #[must_use]
    pub fn id(&self) -> Id
    {
        self.id
    }

    #[must_use]
    pub fn position(&self) -> &Vec3<f32>
    {
        self.transform.position()
    }

    pub fn translate(&mut self, translation: Vec3<f32>)
    {
        self.transform
            .set_position(self.transform.position().clone() + translation);
    }

    pub fn scale(&mut self, scaling: Vec3<f32>)
    {
        self.transform.set_scale(scaling);
    }

    pub fn textures(&self) -> impl Iterator<Item = (&TextureId, &Texture)>
    {
        self.textures.iter()
    }

    #[must_use]
    pub fn material(&self) -> &Material
    {
        &self.material
    }

    #[must_use]
    pub fn mesh(&self) -> &Mesh
    {
        &self.mesh
    }

    #[must_use]
    pub fn shader(&self) -> &ShaderProgram
    {
        &self.shader
    }

    pub(crate) fn transform(&self) -> &Transform
    {
        &self.transform
    }
}

/// Object builder.
#[derive(Debug)]
pub struct Builder
{
    vertices: Vec<Vertex>,
    indices: Option<Vec<u32>>,
    textures: HashMap<TextureId, Texture>,
    material: Option<Material>,
}

impl Builder
{
    /// Returns a new [`Object`] builder.
    #[must_use]
    pub fn new() -> Self
    {
        Self {
            vertices: Vec::new(),
            indices: None,
            textures: HashMap::new(),
            material: None,
        }
    }

    #[must_use]
    pub fn vertices(mut self, vertices: impl IntoIterator<Item = Vertex>) -> Self
    {
        self.vertices = vertices.into_iter().collect();

        self
    }

    #[must_use]
    pub fn indices(mut self, indices: impl IntoIterator<Item = u32>) -> Self
    {
        self.indices = Some(indices.into_iter().collect());

        self
    }

    #[must_use]
    pub fn texture(mut self, id: TextureId, texture: Texture) -> Self
    {
        self.textures.insert(id, texture);

        self
    }

    #[must_use]
    pub fn textures<Textures>(mut self, textures: Textures) -> Self
    where
        Textures: IntoIterator<Item = (TextureId, Texture)>,
    {
        self.textures.extend(textures);

        self
    }

    #[must_use]
    pub fn material(mut self, material: Material) -> Self
    {
        self.material = Some(material);

        self
    }

    /// Builds a new [`Object`].
    ///
    /// # Errors
    /// Will return `Err` if:
    /// - Creating shaders fails
    /// - Linking the shader program fails
    pub fn build(self, id: Id) -> Result<Object, Error>
    {
        let vertex_shader_file = Path::new(SHADER_DIR).join(VERTEX_SHADER_FILE);

        let fragment_shader_file = Path::new(SHADER_DIR).join(FRAGMENT_SHADER_FILE);

        let vertex_shader_content =
            read_to_string(&vertex_shader_file).map_err(|err| {
                Error::ReadShaderFailed {
                    source: err,
                    shader_file: vertex_shader_file.clone(),
                }
            })?;

        let fragment_shader_content =
            read_to_string(&fragment_shader_file).map_err(|err| {
                Error::ReadShaderFailed {
                    source: err,
                    shader_file: fragment_shader_file.clone(),
                }
            })?;

        let shader_preprocessor = ShaderPreprocessor::new(PathBuf::from(SHADER_DIR));

        let vertex_shader_content_preprocessed = shader_preprocessor
            .preprocess(vertex_shader_content, &vertex_shader_file)
            .map_err(|err| Error::PreprocessShaderFailed {
                source: err,
                shader_file: vertex_shader_file,
            })?;

        let frag_shader_content_preprocessed = shader_preprocessor
            .preprocess(fragment_shader_content, &fragment_shader_file)
            .map_err(|err| Error::PreprocessShaderFailed {
                source: err,
                shader_file: fragment_shader_file,
            })?;

        let vertex_shader =
            Self::create_shader(ShaderKind::Vertex, &vertex_shader_content_preprocessed)
                .map_err(Error::CreateVertexShaderFailed)?;

        let fragment_shader =
            Self::create_shader(ShaderKind::Fragment, &frag_shader_content_preprocessed)
                .map_err(Error::CreateFragmentShaderFailed)?;

        let shader_program = ShaderProgram::new();

        shader_program.attach(&vertex_shader);
        shader_program.attach(&fragment_shader);

        shader_program
            .link()
            .map_err(Error::LinkShaderProgramFailed)?;

        let mesh = Mesh::new(self.vertices, self.indices);

        let transform = Transform::new();

        Ok(Object {
            id,
            mesh,
            shader: shader_program,
            transform,
            textures: self.textures,
            material: self.material.ok_or(Error::NoMaterial)?,
        })
    }

    fn create_shader(kind: ShaderKind, source: &str) -> Result<Shader, ShaderError>
    {
        let shader = Shader::new(kind);

        shader.set_source(source)?;
        shader.compile()?;

        Ok(shader)
    }
}

impl Default for Builder
{
    fn default() -> Self
    {
        Self::new()
    }
}

/// Object error
#[derive(Debug, thiserror::Error)]
pub enum Error
{
    #[error("Failed to create vertex shader")]
    CreateVertexShaderFailed(#[source] ShaderError),

    #[error("Failed to create fragment shader")]
    CreateFragmentShaderFailed(#[source] ShaderError),

    #[error("Failed to link shader program")]
    LinkShaderProgramFailed(#[source] ShaderError),

    #[error("Failed to read shader {}", shader_file.display())]
    ReadShaderFailed
    {
        #[source]
        source: IoError,
        shader_file: PathBuf,
    },

    #[error("Failed to preprocess shader {}", shader_file.display())]
    PreprocessShaderFailed
    {
        #[source]
        source: ShaderPreprocessorError,
        shader_file: PathBuf,
    },

    #[error("Object builder has no material")]
    NoMaterial,
}

/// Object ID.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Id
{
    id: u16,
}

impl Id
{
    /// Returns a new object ID.
    #[must_use]
    pub fn new(id: u16) -> Self
    {
        Self { id }
    }
}