use crate::calculus::calculus::{deg2rad, sample_square, Point3, Ray, Vec3};
use crate::common::{get_image_height, Color, DisplayBuffer, Pixel, ASPECT_RATIO, IMG_WIDTH, LOOK_AT, LOOK_FROM, MAX_DEPTH, SAMPLES_PER_PIXEL, VFOV, VUP};
use crate::interval::Interval;
use crate::object::{HitRecord, Hittable, HittableList};

pub struct Camera {
    pub aspect_ratio: f32,
    pub image_width: usize,
    pub samples_per_pixel: usize,
    pub vfov: f32,
    pub look_from: Point3,
    pub look_at: Point3,
    pub vup: Vec3,
    image_height: usize,
    center: Point3,
    pixel_upper_left: Point3,
    delta_pixel_u: Vec3,
    delta_pixel_v: Vec3,
    pixel_samples_scale: f32,
    max_depth: usize,
}

impl Default for Camera {
    fn default() -> Self {
        let aspect_ratio = ASPECT_RATIO;

        let image_width = IMG_WIDTH;
        let image_height = get_image_height(image_width, aspect_ratio);

        let vfov = VFOV;
        let look_from = LOOK_FROM;
        let look_at = LOOK_AT;
        let vup = VUP;

        let center = look_from;
        let focal_length = look_from.sub(&look_at).mag();
        let theta = deg2rad(vfov);
        let h = (theta / 2.0).tan();

        let w = look_from.sub(&look_at).unit();
        let u = vup.cross_prod(&w).unit();
        let v = w.cross_prod(&u).unit();

        let samples_per_pixel = SAMPLES_PER_PIXEL;
        let pixel_samples_scale = 1.0 / samples_per_pixel as f32;

        let viewport_height = 2.0 * h * focal_length;
        let viewport_width = viewport_height * (image_width as f32 / image_height as f32);

        let viewport_u = u.scalar_mul(viewport_width);
        let viewport_v = v.scalar_mul(-1.0).scalar_mul(viewport_height);

        let delta_pixel_u = viewport_u.scalar_mul(1.0 / image_width as f32);
        let delta_pixel_v = viewport_v.scalar_mul(1.0 / image_height as f32);

        let viewport_upper_left = center
            .sub(&w.scalar_mul(focal_length))
            .sub(&viewport_u.scalar_mul(0.5))
            .sub(&viewport_v.scalar_mul(0.5));
        let pixel_upper_left = viewport_upper_left.add(
            &delta_pixel_u.add(&delta_pixel_v).scalar_mul(0.5)
        );

        let max_depth = MAX_DEPTH;

        Self {
            aspect_ratio,
            image_width,
            image_height,
            center,
            pixel_upper_left,
            delta_pixel_u,
            delta_pixel_v,
            samples_per_pixel,
            pixel_samples_scale,
            max_depth,
            vfov,
            look_from,
            look_at,
            vup,
        }
    }
}

impl Camera {
    fn get_ray(&self, i: usize, j: usize) -> Ray {
        let offset = sample_square();
        let pixel_sample = self.pixel_upper_left
            .add(&self.delta_pixel_u.scalar_mul(i as f32 + offset.x))
            .add(&self.delta_pixel_v.scalar_mul(j as f32 + offset.y));

        let ray_origin = self.center;
        let ray_direction = pixel_sample.sub(&ray_origin);

        Ray {
            origin: ray_origin,
            direction: ray_direction,
        }
    }

    fn ray_color(&self, ray: &Ray, world: &HittableList, depth: usize) -> Color {
        if depth <= 0 {
            return Color::new(0.0, 0.0, 0.0);
        }

        let mut rec = HitRecord::default();
        let ray_t = Interval::new(0.001, f32::INFINITY);
        if world.hit(ray, ray_t, &mut rec) {
            let mut scattered: Ray = Ray {
                origin: Vec3::random_unit(),
                direction: Vec3::random_unit(),
            };
            let mut attenuation: Color = Color::new(0.0, 0.0, 0.0);
            if rec.material.scatter(ray, &rec, &mut attenuation, &mut scattered) {
                return attenuation.elem_prod(&self.ray_color(&mut scattered, &world, depth - 1));
            }
            return Color::new(0.0, 0.0, 0.0);
        }

        let unit_direction = ray.direction.unit();
        let a = 0.5 * (unit_direction.y + 1.0);
        let color1 = Color::new(1.0, 1.0, 1.0).mul_scalar(1.0 - a);
        let color2 = Color::new(0.5, 0.7, 1.0).mul_scalar(a);
        color1.add(&color2)
    }

    pub fn render(&self, display_buffer: &mut DisplayBuffer, world: &HittableList) {
        (0..self.image_height).for_each(|j| {
            (0..self.image_width).for_each(|i| {
                println!("Processing line {} col {}", j, i);
                let mut pixel_color = Color::new(0.0, 0.0, 0.0);
                (0..self.samples_per_pixel).for_each(|_| {
                    let r = self.get_ray(i, j);
                    let ray_color = self.ray_color(&r, world, self.max_depth);
                    pixel_color = pixel_color.add(&ray_color);
                });
                pixel_color = pixel_color.mul_scalar(self.pixel_samples_scale);
                display_buffer[j][i] = Pixel::from_color(&pixel_color);
            })
        })
    }
}