//
// This is an abstraction over a drawing environment.
// Future note: z-Buffer is described here:
// https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/perspective-correct-interpolation-vertex-attributes
//
// 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::cmp;
use std::fmt::{Formatter, Display, Result};
use std::ops::{Add, Sub, Div};
use std::sync::mpsc;

pub trait Easel {
    //fn canvas(&mut self, width :u16, height :u16) -> Option<&dyn Canvas>;
}

pub trait Canvas<T> {
    fn init_events(&self);
    fn start_events(&self, tx :mpsc::Sender<i32>);

    fn width(&self) -> u16;
    fn height(&self) -> u16;

    fn clear(&mut self);
    fn draw(&mut self, c :&dyn Drawable<T>, ofs :Coordinate<T>, color :u32);
    fn put_text(&self, ofs :Coordinate<T>, s :&str);
    fn show(&self);
}

pub trait Drawable<T> {
    fn plot(&self) -> Coordinates<T>;
}

#[derive(Debug, Clone, Copy)]
pub struct Coordinate<T>(pub i32, pub i32, pub T);

#[derive(Debug, Clone)]
pub struct Coordinates<T>(pub Vec<Coordinate<T>>);

impl<T> Coordinate<T>
where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
       + Clone + Copy + From<i32> {
    // Tail recursive Bresenham line with integer incremental error.
    fn line(self, b :&Self) -> Vec<Self> {
        fn inner<T>( v :&mut [Coordinate<T>]
                  , bx :i32, by :i32
                  , dx :i32, dy :i32
                  , sx :i32, sy :i32
                  , dz :T, err :i32)
            where T: Add<Output = T> + Copy {

            let Coordinate(x, y, z) = v[0];

            if x != bx || y != by {
                let (x, y, z, err) = match (2*err >= dy, 2*err <= dx) {
                    (true, false) => (x + sx,      y, z + dz,      err + dy ),
                    (false, true) => (     x, y + sy, z + dz,      err + dx ),
                    _             => (x + sx, y + sy, z + dz, err + dx + dy ),
                };
                v[1] = Coordinate(x, y, z);
                inner(&mut v[1..], bx, by, dx, dy, sx, sy, dz, err);
            }
        }

        let Coordinate(ax, ay, az) = self;
        let Coordinate(bx, by, bz) = *b;

        let dx      = (bx - ax).abs();
        let sx :i32 = if ax < bx { 1 } else { -1 };
        let dy      = -(by - ay).abs();
        let sy :i32 = if ay < by { 1 } else { -1 };
        let size    = cmp::max(dx, -dy);
        let dz      = (bz - az) / size.into();

        let mut v :Vec<Self> = vec!( Coordinate(0, 0, 0.into())
                                   ; (size as usize) + 1);
        v[0] = Coordinate(ax, ay, az);
        inner(&mut v, bx, by, dx, dy, sx, sy, dz, dx + dy);
        v
    }
}

impl<T> Display for Coordinate<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        write!(f, "<{},{}>", self.0, self.1)
    }
}

impl<T> Display for Coordinates<T> where T: Copy {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Coordinates(is) = self;

        let c = match is[..] {
            []  => String::from(""),
            [a] => format!("{}", a),
            _   => {
                let mut a = format!("{}", is[0]);
                for i in is[1..].iter() {
                    a = a + &format!(",{}", i);
                }
                a
            }
        };

        write!(f, "Coordinates[{}]", c)
    }
}


#[derive(Debug, Clone, Copy)]
pub struct Point<T>(pub Coordinate<T>);

impl<T> Drawable<T> for Point<T> where T: Copy {
    fn plot(&self) -> Coordinates<T> {
        let Point(c) = *self;
        Coordinates(vec!(c))
    }
}

impl<T> Display for Point<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Point(p) = self;
        write!(f, "Point[{}]", p)
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Line<T>(pub Coordinate<T>, pub Coordinate<T>);

impl<T> Drawable<T> for Line<T>
where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
       + Clone + Copy + From<i32> {
    fn plot(&self) -> Coordinates<T> {
        let Line(a, b) = *self;
        Coordinates(a.line(&b))
    }
}

impl<T> Display for Line<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Line(a, b) = self;
        write!(f, "Line[{},{}]", a, b)
    }
}

// In 3D a rectangle is not as trivial as in 2D, it might be somehow rotate
// and thus we need to specify a Z offset for the other two corners.
// As I do not need rectangle at all I just comment out this code for now.
/*
#[derive(Debug, Clone, Copy)]
pub struct Rectangle<T>(pub Coordinate<T>, pub Coordinate<T>);

impl<T> Drawable<T> for Rectangle<T> {
    fn plot(&self) -> Coordinates<T> {
        let Rectangle(a, c)    = *self;
        let Coordinate(ax, ay, az) = a;
        let Coordinate(cx, cy, cz) = c;
        let b = Coordinate(cx, ay);
        let d = Coordinate(ax, cy);

        let mut r = a.line(&b);
        r.append(&mut b.line(&c)[1..].to_vec());
        r.append(&mut c.line(&d)[1..].to_vec());
        let mut i = d.line(&a);
        let     l = i.len();
        r.append(&mut i[1..l-1].to_vec());

        Coordinates(r)
    }
}

impl Display for Rectangle {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Rectangle(a, b) = self;
        write!(f, "Rec[{},{}]", a, b)
    }
}
*/

#[derive(Debug, Clone)]
pub struct Polyline<T>(pub Coordinates<T>);

impl<T> Drawable<T> for Polyline<T>
where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
       + Clone + Copy + From<i32> {
    fn plot(&self) -> Coordinates<T> {
        let Polyline(Coordinates(cs)) = self;

        match cs[..] {
            []     => Coordinates(Vec::<Coordinate<T>>::new()),
            [a]    => Coordinates(vec!(a)),
            [a, b] => Coordinates(a.line(&b)),
            _      => {
                let (a, b) = (cs[0], cs[1]);
                let mut r = a.line(&b);
                let mut i = b;
                for j in cs[2..].iter() {
                    r.append(&mut i.line(j)[1..].to_vec());
                    i = *j;
                }
                Coordinates(r)
            },
        }
    }
}

impl<T> Display for Polyline<T> where T: Copy {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Polyline(a) = self;
        write!(f, "PLine[{}]", a)
    }
}

#[derive(Debug, Clone)]
pub struct Polygon<T>(pub Coordinates<T>);

impl<T> Drawable<T> for Polygon<T>
where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
       + Clone + Copy + From<i32> {
    fn plot(&self) -> Coordinates<T> {
        let Polygon(Coordinates(cs)) = self;

        match cs[..] {
            []     => Coordinates(Vec::<Coordinate<T>>::new()),
            [a]    => Coordinates(vec!(a)),
            [a, b] => Coordinates(a.line(&b)),
            _      => {
                let (a, b) = (cs[0], cs[1]);
                let mut r = a.line(&b);
                let mut i = b;
                for j in cs[2..].iter() {
                    r.append(&mut i.line(j)[1..].to_vec());
                    i = *j;
                }
                let mut j = a.line(&i);
                let     l = j.len();
                if l > 1 {
                    r.append(&mut j[1..l-1].to_vec());
                }
                Coordinates(r)
            },
        }
    }
}

impl<T> Display for Polygon<T> where T: Copy {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let Polygon(a) = self;
        write!(f, "Poly[{}]", a)
    }
}