use std::fmt::Display;

use binrw::{BinRead, BinWrite};

use crate::{
    field_of::FieldOf,
    types::{Field, ObjectType, Point, WString, F64, U16, U32},
};

use self::{circle::Circle, ellipse::Ellipse, line::Lines, polygon::Polygon, rectangle::Rectangle};

pub mod circle;
pub mod ellipse;
pub mod hatch;
pub mod line;
pub mod polygon;
pub mod rectangle;

#[derive(BinRead, BinWrite, Debug)]
#[brw(magic(17u32))]
pub struct ObjBase {
    pub pen: U32,
    pub obj_type: FieldOf<ObjectType>,
    pub flags: U16,
    pub name: WString,
    pub count: U32,
    _unknown_1: Field,
    pub io_control_enable_mask: U16,
    pub io_control_disable_mask: U16,
    _unknown_2: [Field; 5],
    pub origin: FieldOf<Point>,
    pub z: F64,
    pub a: F64,
    _unknown_3: Field,
}

impl Display for ObjBase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("[{}]", self.obj_type))
    }
}

#[derive(BinRead, BinWrite, Debug)]
pub enum Object {
    #[brw(magic = 1u32)]
    Curve(Lines),
    #[brw(magic = 2u32)]
    Point(Lines),
    #[brw(magic = 3u32)]
    Rectangle(Rectangle),
    #[brw(magic = 4u32)]
    Circle(Circle),
    #[brw(magic = 5u32)]
    Ellipse(Ellipse),
    #[brw(magic = 6u32)]
    Polygon(Polygon),
    // #[brw(magic = 32u32)]
    // Hatch(Hatch),
}

impl Display for Object {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Object::Curve(x) => write!(f, "{}", x),
            Object::Point(x) => write!(f, "{}", x),
            Object::Rectangle(x) => write!(f, "{}", x),
            Object::Circle(x) => write!(f, "{}", x),
            Object::Ellipse(x) => write!(f, "{}", x),
            Object::Polygon(x) => write!(f, "{}", x),
        }
    }
}