backend-local/src/main.rs

use axum::{
    extract::{DefaultBodyLimit, Multipart, Path as AxumPath, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};

use serde::{Deserialize, Serialize};
use std::{
    collections::HashMap,
    path::{Path, PathBuf},
    process::Command,
    sync::{
        atomic::{AtomicU64, Ordering},
        Arc, Mutex,
    },
    time::{Duration, Instant},
};
use tempfile::{NamedTempFile, TempPath};
use tokio::fs;
use tower_http::cors::CorsLayer;
use tracing::{error, info, warn};


async fn get_version() -> impl IntoResponse {
    Json(serde_json::json!({
        "version": "1.0.4",
        "timestamp": chrono::Utc::now().timestamp()
    }))
}

// ─────────────────────────────── Модели ───────────────────────────────

#[derive(Deserialize, Clone, Debug)]
struct PrintSettings {
    filename: String,
    pages: String,
    copies: u32,
    #[serde(rename = "colorMode")]
    color_mode: String,
    format: String,
    #[serde(default)]
    sides: Option<String>,
    #[serde(default)]
    dpi: Option<String>,
}

#[derive(Clone, Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
enum FileStatus {
    Queued,
    Printing,
    AwaitingFlip,
    Awaiting,
    Done,
    Error,
    Cancelled,
}

#[derive(Clone, Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
enum JobPhase {
    WaitingStart,
    Printing,
    AwaitingFlip,
    AwaitingPickup,
    Finished,
    Cancelled,
}

#[derive(Clone, Debug, Serialize)]
struct JobFileView {
    name: String,
    status: FileStatus,
    #[serde(skip_serializing_if = "Option::is_none")]
    error: Option<String>,
    /// true → нечётное кол-во страниц, нужно убрать верхний лист перед 2-м проходом
    #[serde(default)]
    remove_top_sheet: bool,
}

#[derive(Clone, Debug, Serialize)]
struct JobView {
    job_id: String,
    phase: JobPhase,
    files: Vec<JobFileView>,
}

struct JobFile {
    name: String,
    path: TempPath, // живёт, пока жив job → автоочистка temp
    settings: Option<PrintSettings>,
    status: FileStatus,
    error: Option<String>,
}

struct Job {
    id: String,
    files: Vec<JobFile>,
    current: Option<usize>,
    phase: JobPhase,
    cups_id: Option<String>,
}

impl Job {
    fn view(&self) -> JobView {
        JobView {
            job_id: self.id.clone(),
            phase: self.phase.clone(),
            files: self.files.iter().map(|f| {
                JobFileView {
                    name: f.name.clone(),
                    status: f.status.clone(),
                    error: f.error.clone(),
                    remove_top_sheet: Self::should_remove_top_sheet(&f.settings),
                }
            }).collect(),
        }
    }

    /// Нечетных страниц больше, чем чётных → лишний лист сверху
    fn should_remove_top_sheet(settings: &Option<PrintSettings>) -> bool {
        let Some(s) = settings else { return false };
        if s.sides.as_deref() != Some("Двусторонняя") { return false; }
        if s.pages == "all" { return false; } // для офисных не знаем кол-во
        let nums: Vec<u32> = s.pages.split(',')
            .filter_map(|p| p.trim().parse().ok())
            .collect();
        let odd  = nums.iter().filter(|n| *n % 2 == 1).count();
        let even = nums.iter().filter(|n| *n % 2 == 0).count();
        odd > even
    }
}

#[derive(Clone)]
struct SpawnInfo {
    job_id: String,
    idx: usize,
    path: PathBuf,
    settings: Option<PrintSettings>,
    is_second_pass: bool,
}

type JobStore = Arc<Mutex<HashMap<String, Job>>>;
static JOB_COUNTER: AtomicU64 = AtomicU64::new(1);

// ─────────────────────────────── main ───────────────────────────────

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_target(true)
        .with_thread_ids(true)
        .with_file(true)
        .with_line_number(true)
        .init();

    let store: JobStore = Arc::new(Mutex::new(HashMap::new()));
    let cors = CorsLayer::permissive();

    let app = Router::new()
        .route("/version", get(get_version))
        .route("/print", post(create_print))
        .route("/print/{job_id}", get(job_status))
        .route("/print/{job_id}/advance", post(job_advance))
        .route("/print/{job_id}/cancel", post(job_cancel))
        .layer(DefaultBodyLimit::max(50 * 1024 * 1024)) // 50 MB
        .layer(cors)
        .with_state(store);

    info!("🖨️  Print API запущен на http://0.0.0.0:3000");
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .expect("Не удалось забиндить порт 3000");
    axum::serve(listener, app).await.expect("Ошибка сервера");
}

// ─────────────────────────── Обработчики ───────────────────────────

async fn create_print(
    State(store): State<JobStore>,
    mut multipart: Multipart,
) -> Result<Json<JobView>, (StatusCode, String)> {
    info!("📥 Получен запрос на печать (создание задания)");

    let mut settings_map: HashMap<String, PrintSettings> = HashMap::new();
    let mut files_data: Vec<(String, bytes::Bytes)> = Vec::new();

    while let Some(field) = multipart.next_field().await.unwrap_or(None) {
        let field_name = field.name().unwrap_or("").to_string();
        if field_name == "settings" {
            match field.text().await {
                Ok(text) => match serde_json::from_str::<PrintSettings>(&text) {
                    Ok(s) => {
                        info!(filename = %s.filename, "✅ Настройки распарсены");
                        settings_map.insert(s.filename.clone(), s);
                    }
                    Err(e) => error!(raw = %text, error = %e, "❌ Не удалось распарсить settings"),
                },
                Err(e) => error!(error = %e, "❌ Ошибка чтения поля settings"),
            }
        } else if field_name == "files" {
            let file_name = field.file_name().unwrap_or("unknown").to_string();
            match field.bytes().await {
                Ok(data) => {
                    info!(file_name = %file_name, size_bytes = data.len(), "📎 Получен файл");
                    files_data.push((file_name, data));
                }
                Err(e) => error!(file_name = %file_name, error = %e, "❌ Ошибка чтения файла"),
            }
        } else {
            warn!(field_name = %field_name, "⚠️ Неизвестное поле в multipart, пропущено");
        }
    }

    if files_data.is_empty() {
        return Err((
            StatusCode::BAD_REQUEST,
            "В запросе отсутствуют файлы для печати".into(),
        ));
    }

    // Спулим каждый файл во временный (TempPath живёт вместе с job)
    let mut job_files: Vec<JobFile> = Vec::new();
    for (file_name, data) in files_data {
        let ext = Path::new(&file_name)
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("")
            .to_lowercase();
        let temp = if ext.is_empty() {
            NamedTempFile::new()
        } else {
            NamedTempFile::with_suffix(&format!(".{}", ext))
        };
        let temp = match temp {
            Ok(f) => f,
            Err(e) => {
                error!(file_name = %file_name, error = %e, "❌ Не удалось создать temp файл");
                continue;
            }
        };
        let path = temp.into_temp_path();
        if let Err(e) = fs::write(&*path, &data).await {
            error!(file_name = %file_name, error = %e, "❌ Ошибка записи во временный файл");
            continue;
        }
        let settings = settings_map.get(&file_name).cloned();
        if settings.is_none() {
            warn!(file_name = %file_name, "⚠️ Настройки не найдены, печать по умолчанию");
        }
        job_files.push(JobFile {
            name: file_name,
            path,
            settings,
            status: FileStatus::Queued,
            error: None,
        });
    }

    if job_files.is_empty() {
        return Err((
            StatusCode::BAD_REQUEST,
            "Не удалось сохранить ни один файл".into(),
        ));
    }

    let job_id = format!("job-{}", JOB_COUNTER.fetch_add(1, Ordering::SeqCst));
    let job = Job {
        id: job_id.clone(),
        files: job_files,
        current: None,
        phase: JobPhase::WaitingStart,
        cups_id: None,
    };
    let view = job.view();
    store.lock().unwrap().insert(job_id.clone(), job);
    info!(job_id = %job_id, files = view.files.len(), "🆕 Задание создано, ждём старт от клиента");
    Ok(Json(view))
}

async fn job_status(
    State(store): State<JobStore>,
    AxumPath(job_id): AxumPath<String>,
) -> Result<Json<JobView>, (StatusCode, String)> {
    let m = store.lock().unwrap();
    m.get(&job_id)
        .map(|j| Json(j.view()))
        .ok_or_else(|| (StatusCode::NOT_FOUND, format!("Задание {} не найдено", job_id)))
}

/// Подтверждение клиента: старт первого файла ИЛИ «документ забран, печатай следующий»
async fn job_advance(
    State(store): State<JobStore>,
    AxumPath(job_id): AxumPath<String>,
) -> Result<Json<JobView>, (StatusCode, String)> {
    let (view, spawn_info) = {
        let mut m = store.lock().unwrap();
        let job = m.get_mut(&job_id)
            .ok_or_else(|| (StatusCode::NOT_FOUND, format!("Задание {} не найдено", job_id)))?;

        let si = match job.phase {
            JobPhase::WaitingStart => {
                info!(job_id = %job_id, "▶️ Старт первого файла");
                Some(start_printing_locked(job, 0))
            }

            JobPhase::AwaitingFlip => {
                if let Some(c) = job.current {
                    info!(job_id = %job_id, file = %job.files[c].name,
                          "🔄 Запуск второго прохода (чётные страницы)");
                    job.files[c].status = FileStatus::Printing;
                    job.phase = JobPhase::Printing;
                    job.cups_id = None;
                    Some(SpawnInfo {
                        job_id: job.id.clone(),
                        idx: c,
                        path: job.files[c].path.to_path_buf(),
                        settings: job.files[c].settings.clone(),
                        is_second_pass: true,
                    })
                } else {
                    None
                }
            }

            JobPhase::AwaitingPickup => match job.current.take() {
                Some(c) => {
                    job.files[c].status = FileStatus::Done;
                    info!(job_id = %job_id, file = %job.files[c].name, "✔️ Документ забран");
                    begin_next_locked(job, c)
                }
                None => { job.phase = JobPhase::Finished; None }
            },

            _ => None,
        };
        (job.view(), si)
    };

    if let Some(si) = spawn_info {
        spawn_print_task(store.clone(), si);
    }
    Ok(Json(view))
}

async fn job_cancel(
    State(store): State<JobStore>,
    AxumPath(job_id): AxumPath<String>,
) -> Result<Json<JobView>, (StatusCode, String)> {
    let cups_ids: Vec<String> = {
        let mut m = store.lock().unwrap();
        let job = m
            .get_mut(&job_id)
            .ok_or_else(|| (StatusCode::NOT_FOUND, format!("Задание {} не найдено", job_id)))?;
        if job.phase == JobPhase::Finished || job.phase == JobPhase::Cancelled {
            return Ok(Json(job.view()));
        }
        // собираем ВСЕ известные CUPS id для этого job (обычно один, но на всякий случай)
        let ids = job.cups_id.take().into_iter().collect::<Vec<_>>();
        for f in job.files.iter_mut() {
            if matches!(
                f.status,
                FileStatus::Queued | FileStatus::Printing | FileStatus::Awaiting
            ) {
                f.status = FileStatus::Cancelled;
            }
        }
        job.phase = JobPhase::Cancelled;
        job.current = None;
        warn!(job_id = %job_id, "🛑 Задание отменено клиентом");
        ids
    };
    // отменяем каждый известный CUPS-job
    for id in cups_ids {
        let cancel_bin = cups_bin("cancel");
        let _ = tokio::task::spawn_blocking(move || {
            Command::new(cancel_bin).arg(id).env("LC_ALL", "C").output()
        })
        .await;
    }
    // также попробуем отменить по всем заданиям с нашего temp-префикса (belt and suspenders)
    // — но обычно CUPS-id'ов достаточно
    let m = store.lock().unwrap();
    Ok(Json(m.get(&job_id).unwrap().view()))
}

// ─────────────────────── Печать: state machine ───────────────────────

fn start_printing_locked(job: &mut Job, idx: usize) -> SpawnInfo {
    job.files[idx].status = FileStatus::Printing;
    job.current = Some(idx);
    job.phase = JobPhase::Printing;
    job.cups_id = None;
    SpawnInfo {
        job_id: job.id.clone(),
        idx,
        path: job.files[idx].path.to_path_buf(),
        settings: job.files[idx].settings.clone(),
        is_second_pass: false,
    }
}

fn begin_next_locked(job: &mut Job, from: usize) -> Option<SpawnInfo> {
    match (from + 1..job.files.len()).find(|&i| job.files[i].status == FileStatus::Queued) {
        Some(i) => Some(start_printing_locked(job, i)),
        None => {
            job.phase = JobPhase::Finished;
            job.current = None;
            job.cups_id = None;
            info!(job_id = %job.id, "🎉 Задание полностью завершено");
            None
        }
    }
}

fn spawn_print_task(store: JobStore, info: SpawnInfo) {
    tokio::spawn(async move {
        let path     = info.path.clone();
        let settings = info.settings.clone();

        let is_duplex = settings.as_ref()
            .map(|s| s.sides.as_deref() == Some("Двусторонняя"))
            .unwrap_or(false);

        let duplex_pass: Option<&str> = if is_duplex {
            if info.is_second_pass { Some("even") } else { Some("odd") }
        } else {
            None
        };

        // 1) Спулим в CUPS
        let p = path.clone();
        let s = settings.clone();
        let dp = duplex_pass.map(|d| d.to_string());
        let spool = tokio::task::spawn_blocking(move || {
            run_lp(&p, s.as_ref(), dp.as_deref())
        }).await;

        let cups_id = match spool {
            Ok(Ok(id)) => id,
            Ok(Err(e)) => return mark_error_and_continue(store, info, e).await,
            Err(e)     => return mark_error_and_continue(store, info, format!("spawn: {}", e)).await,
        };

        // 2) Ждём физического завершения
        if !cups_id.is_empty() {
            {
                let mut m = store.lock().unwrap();
                if let Some(job) = m.get_mut(&info.job_id) {
                    if job.phase != JobPhase::Cancelled {
                        job.cups_id = Some(cups_id.clone());
                    } else { return; }
                } else { return; }
            }
            let cid = cups_id.clone();
            let wait = tokio::task::spawn_blocking(move || wait_for_cups(&cid)).await;
            match wait {
                Ok(Ok(())) => {}
                Ok(Err(e)) => return mark_error_and_continue(store, info, e).await,
                Err(e)     => return mark_error_and_continue(store, info, format!("spawn: {}", e)).await,
            }
        }

        // 3) Обновляем статус
        let mut m = store.lock().unwrap();
        let job = match m.get_mut(&info.job_id) { Some(j) => j, None => return };

        if job.phase == JobPhase::Cancelled { return; }
        if job.files.get(info.idx).map(|f| f.status.clone()) != Some(FileStatus::Printing) { return; }

        if is_duplex && !info.is_second_pass {
            // Первый проход завершён → ждём, пока пользователь переложит бумагу
            job.files[info.idx].status = FileStatus::AwaitingFlip;
            job.phase = JobPhase::AwaitingFlip;
            job.cups_id = None;
            info!(job_id = %info.job_id, file = %job.files[info.idx].name,
                  "🔄 Первый проход завершён, ждём переворота бумаги");
        } else {
            // Обычная печать или второй проход дуплекса → ждём, пока заберут
            job.files[info.idx].status = FileStatus::Awaiting;
            job.phase = JobPhase::AwaitingPickup;
            job.cups_id = None;
            info!(job_id = %info.job_id, file = %job.files[info.idx].name,
                  "✅ Печать завершена, ждём подтверждения");
        }
    });
}

async fn mark_error_and_continue(store: JobStore, info: SpawnInfo, msg: String) {
    error!(job_id = %info.job_id, idx = info.idx, error = %msg, "❌ Ошибка печати файла");
    let next = {
        let mut m = store.lock().unwrap();
        let job = match m.get_mut(&info.job_id) {
            Some(j) => j,
            None => return,
        };
        if job.phase == JobPhase::Cancelled {
            return;
        }
        if let Some(f) = job.files.get_mut(info.idx) {
            if f.status != FileStatus::Printing {
                return;
            }
            f.status = FileStatus::Error;
            f.error = Some(msg);
        }
        begin_next_locked(job, info.idx)
    };
    if let Some(si) = next {
        spawn_print_task(store, si);
    }
}

// ─────────────────────────── lp / lpstat ───────────────────────────

/// Ищем бинарник CUPS в известных локациях (NixOS/Guix/стандартный Linux)
fn cups_bin(name: &str) -> std::path::PathBuf {
    let candidates = [
        format!("/pkg/gnu/cups/bin/{}", name),   // Guix
        format!("/run/current-system/sw/bin/{}", name), // NixOS
        format!("/usr/bin/{}", name),
        format!("/usr/local/bin/{}", name),
    ];
    for p in &candidates {
        let path = std::path::Path::new(p);
        if path.exists() {
            return path.to_path_buf();
        }
    }
    // fallback — надеемся на PATH
    std::path::PathBuf::from(name)
}

fn normalize_format(format: &str) -> String {
    match format.trim() {
        "" | "Авто" | "auto" => String::new(),
        "10x15" => "10x15cm".to_string(),
        other => other.to_string(),
    }
}

fn run_lp(path: &Path, settings: Option<&PrintSettings>, duplex_pass: Option<&str>) -> Result<String, String> {
    let lp = cups_bin("lp");
    let mut cmd = Command::new(&lp);

    if let Some(s) = settings {
        cmd.arg("-n").arg(s.copies.to_string());

        if s.pages != "all" && !s.pages.is_empty() {
            cmd.arg("-P").arg(&s.pages);
        }
        if s.color_mode == "bw" {
            cmd.arg("-o").arg("ColorModel=Gray");
        }
        let fmt = normalize_format(&s.format);
        if !fmt.is_empty() {
            cmd.arg("-o").arg(format!("PageSize={}", fmt));
        }

        // Аппаратный дуплекс только если НЕ ручная двухпроходная печать
        if s.sides.as_deref() == Some("Двусторонняя") && duplex_pass.is_none() {
            cmd.arg("-o").arg("sides=two-sided-long-edge");
        }

        if let Some(d) = s.dpi.as_deref() {
            if !d.is_empty() && d != "Авто" {
                cmd.arg("-o").arg(format!("printer-resolution={}dpi", d));
            }
        }
    }

    // Выбор лотка (InputSlot)
    if let Some(pass) = duplex_pass {
        if pass == "even" {
            // Второй проход (чётные страницы) — ручная подача
            cmd.arg("-o").arg("InputSlot=Manual");
            // Поворот на 180° для второго прохода
            cmd.arg("-o").arg("orientation-requested=6");
        } else {
            // Первый проход (нечётные страницы) — нижний лоток
            cmd.arg("-o").arg("InputSlot=Lower");
        }
    } else {
        // Обычная печать — нижний лоток
        cmd.arg("-o").arg("InputSlot=Lower");
    }

    // Ручной дуплекс: разбивка на чёт/нечёт
    match duplex_pass {
        Some("odd") => {
            cmd.arg("-o").arg("page-set=odd");
        }
        Some("even") => {
            cmd.arg("-o").arg("page-set=even");
            cmd.arg("-o").arg("outputorder=reverse");
        }
        _ => {}
    }

    cmd.arg(path);

    let args: Vec<String> = cmd.get_args().map(|a| a.to_string_lossy().to_string()).collect();
    info!(command = format!("{} {}", lp.display(), args.join(" ")), "🖨️ Команда печати");

    // ВАЖНО: LC_ALL=C гарантирует, что ответ будет на английском и парсинг ID не сломается
    let out = cmd.env("LC_ALL", "C").output().map_err(|e| format!("Не удалось запустить lp: {}", e))?;
    if !out.status.success() {
        return Err(String::from_utf8_lossy(&out.stderr).trim().to_string());
    }
    let stdout = String::from_utf8_lossy(&out.stdout).to_string();
    Ok(stdout.split_whitespace().nth(3).unwrap_or("").to_string())
}

fn has_job_in(output: &Option<String>, id: &str) -> bool {
    output
        .as_deref()
        .map(|s| {
            s.lines()
                .any(|l| l.split_whitespace().next() == Some(id))
        })
        .unwrap_or(false)
}

fn lpstat_raw(which: &str) -> Option<String> {
    let lpstat = cups_bin("lpstat");
    Command::new(&lpstat)
        .arg("-W")
        .arg(which)
        .arg("-o")
        .env("LC_ALL", "C")
        .output()
        .ok()
        .filter(|o| o.status.success())
        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
}

fn wait_for_cups(id: &str) -> Result<(), String> {
    let lpstat_path = cups_bin("lpstat");
    if !lpstat_path.exists() && lpstat_path.to_str().unwrap_or("") == "lpstat" {
        if Command::new("which")
            .arg("lpstat")
            .env("LC_ALL", "C")
            .output()
            .map(|o| !o.status.success())
            .unwrap_or(true)
        {
            return Err(
                "lpstat не найден — не могу отслеживать статус печати в CUPS".into(),
            );
        }
    }

    let started = Instant::now();
    let timeout = Duration::from_secs(30 * 60); // 30 минут максимум

    let probe = lpstat_raw("not-completed");
    if probe.is_none() {
        return Err("lpstat не отвечает (возможно, не запущен cupsd)".into());
    }

    // Получаем имя принтера по умолчанию для проверки физического статуса
    let printer_name = get_default_printer().unwrap_or_else(|| "Auto_HP_P2015".to_string());

    loop {
        let not_completed = lpstat_raw("not-completed");
        let in_queue = has_job_in(&not_completed, id);

        if !in_queue {
            // Задачи уже нет в очереди CUPS. Проверяем, допечатал ли принтер физически.
            if !is_printer_physically_printing(&printer_name) {
                info!(cups_id = %id, "✔ CUPS-задание выполнено и принтер физически допечатал");
                return Ok(());
            } else {
                info!(cups_id = %id, "⏳ CUPS передал данные, но принтер всё ещё физически печатает из буфера...");
            }
        }

        if started.elapsed() > timeout {
            return Err("Таймаут ожидания завершения печати (30 мин)".into());
        }

        std::thread::sleep(Duration::from_millis(1500));
    }
}

fn get_default_printer() -> Option<String> {
    let out = Command::new("lpstat")
        .arg("-d")
        .env("LC_ALL", "C")
        .output()
        .ok()?;
    let stdout = String::from_utf8_lossy(&out.stdout);
    // Формат: "system default destination: Auto_HP_P2015"
    stdout.split(':').nth(1).map(|s| s.trim().to_string())
}

fn is_printer_physically_printing(printer_name: &str) -> bool {
    if let Ok(out) = Command::new("lpstat")
        .arg("-p")
        .arg(printer_name)
        .env("LC_ALL", "C")
        .output() 
    {
        let stdout = String::from_utf8_lossy(&out.stdout);
        // "now printing" или "processing" означают, что принтер физически печатает из буфера
        if stdout.contains("now printing") || stdout.contains("processing") {
            return true;
        }
    }
    false
}