// DIVIDE and MEASURE place points or block references along a curve.
use acadrust::entities::{Insert, Point as PointEnt};
use acadrust::types::Vector3;
use acadrust::{Entity, EntityType, Handle};
use cadkernel::space::PlanarCurve;
use glam::DVec3;
use crate::command::{CadCommand, CmdOption, CmdResult, CurveMarker, WorkingPlane};
use crate::entities::curve::{entity_curve, entity_spatial_measurement};
use crate::t;
const MEASURE: bool = false;

#[derive(Clone, Copy, PartialEq)]
enum Step { Pick, Amount, BlockName, Align }

pub struct DivisionMarkerCommand {
    target: Option<Handle>,
    pick_point: DVec3,
    step: Step,
    blocks: Vec<String>,
    block: Option<String>,
    align: bool,
    plane: WorkingPlane,
    valid_pick: bool,
}

pub type DivideCommand = DivisionMarkerCommand;

impl DivisionMarkerCommand {
    pub fn new() -> Self {
        Self { target: None, pick_point: DVec3::ZERO, step: Step::Pick,
            blocks: Vec::new(), block: None, align: true,
            plane: WorkingPlane::default(), valid_pick: false }
    }
    pub fn with_blocks(mut self, blocks: Vec<String>) -> Self {
        self.blocks = blocks;
        self
    }
    fn marker(&self) -> Option<CurveMarker> {
        self.block.as_ref().map(|name| CurveMarker {
            block: name.clone(), align: self.align, plane: self.plane,
        })
    }
}

impl CadCommand for DivisionMarkerCommand {
    fn name(&self) -> &'static str { if MEASURE { "MEASURE" } else { "DIVIDE" } }
    fn prompt(&self) -> String {
        let prompt = match self.step {
            Step::Pick if MEASURE => "Select object to measure:",
            Step::Pick => "Select object to divide:",
            Step::BlockName => "Enter name of block to insert:",
            Step::Align => "Align block with object? [Yes/No] <Yes>:",
            Step::Amount if MEASURE && self.block.is_none() => "Specify length of segment or [Block]:",
            Step::Amount if MEASURE => "Specify length of segment:",
            Step::Amount if self.block.is_none() => "Enter number of segments or [Block]:",
            Step::Amount => "Enter number of segments:",
        };
        format!("{}  {}", self.name(), prompt)
    }
    fn options(&self) -> Vec<CmdOption> {
        match self.step {
            Step::Amount if self.block.is_none() => vec![CmdOption::new("Block", "B")],
            Step::Align => vec![CmdOption::new("Yes", "Y"), CmdOption::new("No", "N")],
            _ => vec![],
        }
    }
    fn set_working_plane(&mut self, plane: WorkingPlane) { self.plane = plane; }
    fn needs_entity_pick(&self) -> bool { self.step == Step::Pick }
    fn inject_before_entity_pick(&self) -> bool { true }
    fn inject_picked_entity(&mut self, entity: EntityType) {
        self.valid_pick = measurable(&entity).is_some();
    }
    fn on_entity_pick(&mut self, handle: Handle, pt: DVec3) -> CmdResult {
        if handle.is_null() || !self.valid_pick { return CmdResult::NeedPoint; }
        self.target = Some(handle);
        self.pick_point = pt;
        self.step = Step::Amount;
        CmdResult::NeedPoint
    }
    fn wants_text_input(&self) -> bool { self.step != Step::Pick }
    fn dyn_field(&self) -> crate::command::DynField {
        if self.step == Step::Amount { crate::command::DynField::Scalar }
        else { crate::command::DynField::Point }
    }
    fn dyn_commit_as_text(&self) -> bool { self.step == Step::Amount }
    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
        let text = text.trim();
        match self.step {
            Step::BlockName => {
                self.block = Some(self.blocks.iter().find(|name| name.eq_ignore_ascii_case(text))?.clone());
                self.step = Step::Align;
            }
            Step::Align => {
                self.align = match text.to_ascii_uppercase().as_str() {
                    "Y" | "YES" => true,
                    "N" | "NO" => false,
                    _ => return None,
                };
                self.step = Step::Amount;
            }
            Step::Amount => {
                if self.block.is_none() && matches!(text.to_ascii_uppercase().as_str(), "B" | "BLOCK") {
                    self.step = Step::BlockName;
                } else {
                    let n = text.parse::<usize>().ok().filter(|n| (2..=32767).contains(n))?;
                    return Some(CmdResult::DivideEntity { handle: self.target?, n, marker: self.marker() });
                }
            }
            Step::Pick => return None,
        }
        Some(CmdResult::NeedPoint)
    }
    fn on_point(&mut self, _pt: DVec3) -> CmdResult { CmdResult::NeedPoint }
    fn on_enter(&mut self) -> CmdResult {
        if self.step == Step::Align {
            self.align = true;
            self.step = Step::Amount;
            CmdResult::NeedPoint
        } else { CmdResult::Cancel }
    }
}


pub struct MeasureCommand {
    target: Option<Handle>,
    waiting_for_dist: bool,
}

impl MeasureCommand {
    pub fn new() -> Self {
        Self {
            target: None,
            waiting_for_dist: false,
        }
    }
}

impl CadCommand for MeasureCommand {
    fn name(&self) -> &'static str {
        "MEASURE"
    }

    fn prompt(&self) -> String {
        if self.target.is_none() {
            t!("MEASURE  Select object to measure:").into_owned()
        } else {
            t!("MEASURE  Specify segment length:").into_owned()
        }
    }

    fn needs_entity_pick(&self) -> bool {
        self.target.is_none()
    }

    fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult {
        if handle.is_null() {
            return CmdResult::NeedPoint;
        }
        self.target = Some(handle);
        self.waiting_for_dist = true;
        CmdResult::NeedPoint
    }

    fn wants_text_input(&self) -> bool {
        self.waiting_for_dist
    }

    fn dyn_field(&self) -> crate::command::DynField {
        if self.waiting_for_dist {
            crate::command::DynField::Scalar
        } else {
            crate::command::DynField::Point
        }
    }

    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
        let dist: f64 = text
            .trim()
            .replace(',', ".")
            .parse()
            .ok()
            .filter(|&d: &f64| d > 0.0)?;
        let handle = self.target?;
        self.waiting_for_dist = false;
        Some(CmdResult::MeasureEntity {
            handle,
            segment_length: dist,
        })
    }

    fn on_point(&mut self, _pt: DVec3) -> CmdResult {
        CmdResult::NeedPoint
    }
    fn on_enter(&mut self) -> CmdResult {
        CmdResult::Cancel
    }
}


pub fn divide_entity(entity: &EntityType, n: usize, marker: Option<&CurveMarker>) -> Vec<EntityType> {
    if !(2..=32767).contains(&n) {
        return vec![];
    }
    let Some((curve, total)) = measurable(entity) else {
        return vec![];
    };
    let step = total / n as f64;
    let last = if curve.is_closed() { n } else { n - 1 };
    (1..=last)
        .map(|k| make_marker(&curve, step * k as f64, marker))
        .collect()
}

pub fn measure_entity(entity: &EntityType, segment_length: f64) -> Vec<EntityType> {
    if segment_length <= 0.0 {
        return vec![];
    }
    let Some(curve) = entity_curve(entity) else {
        return vec![];
    };
    let total = curve.length();
    if !total.is_finite() || total <= 1e-10 { return vec![]; }
    let mut pts = Vec::new();
    let mut walked = segment_length;
    while walked < total - 1e-6 {
        pts.push(make_point(curve.point_at_distance(walked)));
        walked += segment_length;
    }
    pts
}

fn make_marker(curve: &MeasuredCurve, distance: f64, marker: Option<&CurveMarker>) -> EntityType {
    let pos = curve.point_at_distance(distance);
    let Some(marker) = marker else {
        let mut point = PointEnt::new();
        point.location = Vector3::new(pos[0], pos[1], pos[2]);
        return EntityType::Point(point);
    };
    let local = marker.plane.to_local(DVec3::from_array(pos));
    let mut insert = Insert::new(marker.block.clone(), Vector3::new(local.x, local.y, local.z));
    if marker.align {
        let tangent = DVec3::from_array(curve.tangent_at(curve.parameter_at_distance(distance)));
        let tangent = marker.plane.vector_to_local(tangent);
        insert.rotation = tangent.y.atan2(tangent.x);
    }
    insert.apply_transform(&marker.plane.to_world_transform());
    EntityType::Insert(insert)
}

fn make_point(pos: [f64; 3]) -> EntityType {
    let mut p = PointEnt::new();
    p.location = Vector3::new(pos[0], pos[1], pos[2]);
    EntityType::Point(p)
}

/// The entity's curve and its length, or `None` for anything that cannot be
/// walked along — a hatch, a block, an unbounded ray.
enum MeasuredCurve {
    Planar(PlanarCurve),
    Spatial(cadkernel::space::ArcLengthCurve3),
}
impl MeasuredCurve {
    fn is_closed(&self) -> bool {
        match self { Self::Planar(curve) => curve.is_closed(), Self::Spatial(curve) => curve.is_closed() }
    }
    fn point_at_distance(&self, distance: f64) -> [f64; 3] {
        match self { Self::Planar(curve) => curve.point_at_distance(distance), Self::Spatial(curve) => curve.point_at_distance(distance) }
    }
    fn parameter_at_distance(&self, distance: f64) -> f64 {
        match self { Self::Planar(curve) => curve.parameter_at_distance(distance), Self::Spatial(curve) => curve.parameter_at_distance(distance) }
    }
    fn tangent_at(&self, parameter: f64) -> [f64; 3] {
        match self { Self::Planar(curve) => curve.tangent_at(parameter), Self::Spatial(curve) => curve.tangent_at(parameter) }
    }
}

fn measurable(entity: &EntityType) -> Option<(MeasuredCurve, f64)> {
    let (curve, total) = if let Some(curve) = entity_curve(entity) {
        let total = curve.length();
        (MeasuredCurve::Planar(curve), total)
    } else {
        let curve = entity_spatial_measurement(entity)?;
        let total = curve.length();
        (MeasuredCurve::Spatial(curve), total)
    };
    (total.is_finite() && total > 1e-10).then_some((curve, total))
}

inventory::submit!(crate::command::CommandRegistration { names: &["DIVIDE"] });
inventory::submit!(crate::command::CommandRegistration { names: &["MEASURE"] });