建設業・工務店・一人親方の「働き方改革・残業規制」を救う：
スマホ3タップで終わる見積・安全書類・工事写真台帳の自動化

#![forbid(unsafe_code)]

/// Metadata for a construction site photo with 64-bit perceptual hash and sharpness score.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SitePhotoMeta {
    pub photo_id: u32,
    pub timestamp_sec: u64,
    pub phash_64: u64,
    pub sharpness_score: u32,
}

/// Computes the Hamming distance between two 64-bit perceptual hashes in a single CPU instruction.
#[inline]
pub const fn phash_hamming_distance(a: u64, b: u64) -> u32 {
    (a ^ b).count_ones()
}

/// Clusters burst photos taken within `max_time_gap_sec` and `max_hamming_dist`,
/// returning only the sharpest representative photo ID for each cluster.
pub fn select_sharpest_unique_photos(
    photos: &[SitePhotoMeta],
    max_time_gap_sec: u64,
    max_hamming_dist: u32,
) -> Vec<SitePhotoMeta> {
    let mut selected: Vec<SitePhotoMeta> = Vec::new();
    for &candidate in photos {
        if let Some(last) = selected.last_mut() {
            let time_diff = candidate.timestamp_sec.abs_diff(last.timestamp_sec);
            let dist = phash_hamming_distance(candidate.phash_64, last.phash_64);
            if time_diff <= max_time_gap_sec && dist <= max_hamming_dist {
                if candidate.sharpness_score > last.sharpness_score {
                    *last = candidate;
                }
                continue;
            }
        }
        selected.push(candidate);
    }
    selected
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConstructionTask {
    pub task_id: usize,
    pub duration_days: u32,
    pub predecessors: Vec<usize>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CpmTaskSchedule {
    pub task_id: usize,
    pub earliest_start: u32,
    pub earliest_finish: u32,
    pub latest_start: u32,
    pub latest_finish: u32,
    pub total_float: u32,
    pub is_critical: bool,
}

/// Computes the Critical Path Method (CPM) schedule for a topologically ordered task list.
/// Returns `None` if a predecessor index is out of topological order (cycle or invalid reference).
pub fn solve_critical_path_schedule(tasks: &[ConstructionTask]) -> Option<Vec<CpmTaskSchedule>> {
    let n = tasks.len();
    if n == 0 {
        return Some(Vec::new());
    }

    let mut es = vec![0u32; n];
    let mut ef = vec![0u32; n];

    // Forward pass: compute Earliest Start (ES) and Earliest Finish (EF)
    for (idx, task) in tasks.iter().enumerate() {
        if task.task_id != idx {
            return None;
        }
        let mut max_pred_ef = 0u32;
        for &pred in &task.predecessors {
            if pred >= idx {
                return None; — Enforces strict DAG topological ordering
            }
            if ef[pred] > max_pred_ef {
                max_pred_ef = ef[pred];
            }
        }
        es[idx] = max_pred_ef;
        ef[idx] = max_pred_ef.saturating_add(task.duration_days);
    }

    let project_duration = ef.iter().copied().max().unwrap_or(0);
    let mut lf = vec![project_duration; n];
    let mut ls = vec![0u32; n];

    // Backward pass: compute Latest Finish (LF) and Latest Start (LS)
    for idx in (0..n).rev() {
        ls[idx] = lf[idx].saturating_sub(tasks[idx].duration_days);
        for &pred in &tasks[idx].predecessors {
            if ls[idx] < lf[pred] {
                lf[pred] = ls[idx];
            }
        }
    }

    let mut result = Vec::with_capacity(n);
    for idx in 0..n {
        let total_float = ls[idx].saturating_sub(es[idx]);
        result.push(CpmTaskSchedule {
            task_id: idx,
            earliest_start: es[idx],
            earliest_finish: ef[idx],
            latest_start: ls[idx],
            latest_finish: lf[idx],
            total_float,
            is_critical: total_float == 0,
        });
    }
    Some(result)
}