//
// Basic geometric things...
//
// Georg Hopp <georg@steffers.org>
//
// Copyright © 2019 Georg Hopp
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
use std::convert::From;
use std::ops::{Add,Sub,Neg,Mul,Div};
use std::fmt::Debug;

use crate::easel::{Canvas,Coordinate,Coordinates,Polygon};
use crate::transform::TMatrix;
use crate::trigonometry::Trig;
use crate::vector::Vector;

#[derive(Debug)]
pub struct Polyeder<T>
where T: Add + Sub + Neg + Mul + Div + Copy + Trig {
    points :Vec<Vector<T>>,
    faces  :Vec<Vec<usize>>,
}

pub trait Primitives<T>
where T: Add + Sub + Neg + Mul + Div + Copy + Trig + From<i32> {
    fn transform(&self, m :&TMatrix<T>) -> Self;
    fn project(&self, camera :&Camera<T>) -> Vec<Polygon>;
}

pub struct Camera<T>
where T: Add + Sub + Neg + Mul + Div + Copy + Trig {
    width  :T,
    height :T,
    fovx   :T,
    fovy   :T,
}

impl<T> Camera<T>
where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
       + Mul<Output = T> + Div<Output = T>
       + Copy + Trig + From<i32> {
    pub fn new(c :&dyn Canvas, angle :i32) -> Self {
        let  width = <T as From<i32>>::from(c.width() as i32);
        let height = <T as From<i32>>::from(c.height() as i32);

        // The calculations for fovx and fovy are taken from a book, but I
        // have the impression, coming from my limited algebra knowledge,
        // that they are always equal…
        Camera { width:  width
               , height: height
               , fovx:   T::cot(angle) * width
               , fovy:   width / height * T::cot(angle) * height }
    }

    pub fn project(&self, v :Vector<T>) -> Coordinate {
        let f2 = From::<i32>::from(2);
        let xs = v.x() / v.z() * self.fovx + self.width  / f2;
        let ys = v.y() / v.z() * self.fovy + self.height / f2;

        Coordinate(T::round(&xs), T::round(&ys))
    }
}

impl<T> Polyeder<T>
where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
       + Mul<Output = T> + Div<Output = T>
       + Copy + Trig + From<i32> {
    // https://rechneronline.de/pi/tetrahedron.php
    pub fn tetrahedron(a :T) -> Polyeder<T> {
        let  f0 :T = From::<i32>::from(0);
        let  f3 :T = From::<i32>::from(3);
        let  f4 :T = From::<i32>::from(4);
        let  f6 :T = From::<i32>::from(6);
        let f12 :T = From::<i32>::from(12);

        let yi :T = a / f12 * T::sqrt(f6).unwrap();
        let yc :T = a /  f4 * T::sqrt(f6).unwrap();
        let zi :T = T::sqrt(f3).unwrap() / f6 * a;
        let zc :T = T::sqrt(f3).unwrap() / f3 * a;
        let ah :T = a / From::<i32>::from(2);

        // half the height in y
        let _yh :T = a /  f6 * T::sqrt(f6).unwrap();
        // half the deeps in z
        let _zh :T = T::sqrt(f3).unwrap() / f4 * a;

        Polyeder{ points: vec!( Vector( f0,  yc,  f0)
                              , Vector(-ah, -yi, -zi)
                              , Vector( ah, -yi, -zi)
                              , Vector( f0, -yi,  zc) )
                , faces:  vec!( vec!(1, 2, 3)
                              , vec!(1, 0, 2)
                              , vec!(3, 0, 1)
                              , vec!(2, 0, 3) )}
    }

    pub fn cube(a :T) -> Polyeder<T> {
        let ah :T = a / From::<i32>::from(2);

        Polyeder{ points: vec!( Vector(-ah,  ah, -ah)    // 0 => front 1
                              , Vector(-ah, -ah, -ah)    // 1 => front 2
                              , Vector( ah, -ah, -ah)    // 2 => front 3
                              , Vector( ah,  ah, -ah)    // 3 => front 4
                              , Vector(-ah,  ah,  ah)    // 4 => back 1
                              , Vector(-ah, -ah,  ah)    // 5 => back 2
                              , Vector( ah, -ah,  ah)    // 6 => back 3
                              , Vector( ah,  ah,  ah) )  // 7 => back 4
                , faces:  vec!( vec!(0, 1, 2, 3)         // front
                              , vec!(7, 6, 5, 4)         // back
                              , vec!(1, 5, 6, 2)         // top
                              , vec!(0, 3, 7, 4)         // bottom
                              , vec!(0, 4, 5, 1)         // left
                              , vec!(2, 6, 7, 3) )}      // right
    }
}

impl<T> Primitives<T> for Polyeder<T>
where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
       + Mul<Output = T> + Div<Output = T>
       + Copy + Trig + From<i32> + From<i32> {
    fn transform(&self, m :&TMatrix<T>) -> Self {
        Polyeder{ points: self.points.iter().map(|p| m.apply(p)).collect()
                , faces:  self.faces.to_vec() }
    }

    fn project(&self, camera :&Camera<T>) -> Vec<Polygon> {
        fn polygon<I>(c :I) -> Polygon
        where I: Iterator<Item = Coordinate> {
            Polygon(Coordinates(c.collect()))
        }

        let to_coord = |p :&usize| camera.project(self.points[*p]);
        let to_poly  = |f :&Vec<usize>| polygon(f.iter().map(to_coord));

        self.faces.iter().map(to_poly).collect()
    }
}