partitioning.rs

// DEPRECATED: Superseded by `crate::core::storage::StoragePlan` + `StoragePlanner`.
// Kept temporarily so existing integration tests in tests/logic.rs still compile.
// Remove once those tests migrate to the storage planner API.

use crate::core::state::AppState;

#[derive(Clone, Debug)]
pub struct PartitionPlan {
    pub commands: Vec<String>,
}

impl PartitionPlan {
    pub fn new(commands: Vec<String>) -> Self {
        Self { commands }
    }
}

pub struct PartitioningService;

impl PartitioningService {
    pub fn build_plan(state: &AppState, device: &str) -> PartitionPlan {
        let mut part_cmds: Vec<String> = Vec::new();

        // Check if manual partitioning mode is selected
        let is_manual_mode = state.disks_mode_index == 1;

        if is_manual_mode && !state.disks_partitions.is_empty() {
            // Manual partitioning mode: process the disks_partitions vector
            Self::build_manual_partition_plan(state, device, &mut part_cmds);
        } else {
            // Best-effort automatic partitioning mode
            Self::build_automatic_partition_plan(state, device, &mut part_cmds);
        }

        // Debug summary (no raw command strings)
        let label = state.disks_label.clone().unwrap_or_else(|| "gpt".into());
        let align = state.disks_align.clone().unwrap_or_else(|| "1MiB".into());
        if is_manual_mode {
            let mut specs = Vec::new();
            for p in state.disks_partitions.iter() {
                if let Some(spec_device) = &p.name
                    && spec_device != device
                {
                    continue;
                }
                let role = p.role.clone().unwrap_or_else(|| "OTHER".into());
                let fs = p.fs.clone().unwrap_or_else(|| "ext4".into());
                let size = p.size.clone().unwrap_or_else(|| "?".into());
                specs.push(format!("{role}:{fs}:{size}"));
            }
            state.debug_log(&format!(
                "partitioning: manual device={} label={} wipe={} align={} specs_count={} [{}]",
                device,
                label,
                state.disks_wipe,
                align,
                specs.len(),
                specs.join(", ")
            ));
        } else {
            state.debug_log(&format!(
                "partitioning: auto device={} label={} wipe={} align={} uefi={} swap={} luks={}",
                device,
                label,
                state.disks_wipe,
                align,
                state.is_uefi(),
                state.swap_enabled,
                state.disk_encryption_type_index == 1
            ));
        }

        PartitionPlan::new(part_cmds)
    }

    fn build_automatic_partition_plan(state: &AppState, device: &str, part_cmds: &mut Vec<String>) {
        // NOTE: LVM/RAID and btrfs subvolume layouts are handled by StoragePlanner (Phase 4-6).
        let label = state.disks_label.clone().unwrap_or_else(|| "gpt".into());
        if state.disks_wipe {
            part_cmds.push(format!("wipefs -a {device}"));
        }

        let align = state.disks_align.clone().unwrap_or_else(|| "1MiB".into());
        part_cmds.push(format!("parted -s {device} mklabel {label}"));
        part_cmds.push(format!("partprobe {device} || true"));
        part_cmds.push("udevadm settle".into());

        let mut next_start = align.clone();
        // If system boots via UEFI, always create an ESP as partition 1
        if state.is_uefi() {
            part_cmds.push(format!(
                "parted -s {device} mkpart ESP fat32 {next_start} 1025MiB"
            ));
            part_cmds.push(format!("parted -s {device} set 1 esp on"));
            part_cmds.push(format!(
                "mkfs.fat -F 32 {}",
                Self::get_partition_path(device, 1)
            ));
            next_start = "1025MiB".into();
        } else {
            part_cmds.push(format!(
                "parted -s {device} mkpart biosboot {next_start} 2MiB"
            ));
            part_cmds.push(format!("parted -s {device} set 1 bios_grub on"));
            next_start = "2MiB".into();
        }

        let swap_part_num: u32 = 2;
        let root_part_num: u32 = if state.swap_enabled { 3 } else { 2 };
        let swap_part_path = Self::get_partition_path(device, swap_part_num);
        let root_part_path = Self::get_partition_path(device, root_part_num);

        if state.swap_enabled {
            let swap_start_mib: u64 = if state.is_uefi() { 1025 } else { 2 };
            let swap_end_mib = swap_start_mib + state.swap_size_mib;
            let swap_end = format!("{swap_end_mib}MiB");
            part_cmds.push(format!(
                "parted -s {device} mkpart swap linux-swap {next_start} {swap_end}"
            ));
            part_cmds.push(format!("mkswap {swap_part_path}"));
            next_start = swap_end;
        }

        part_cmds.push(format!(
            "parted -s {device} mkpart root btrfs {next_start} 100%"
        ));
        let luks = state.disk_encryption_type_index == 1;
        if luks {
            // Legacy string plan (bash -lc each line). Real installs use StoragePlanner + InstallCmd.
            part_cmds.push(
                "modprobe -q dm_crypt 2>/dev/null || modprobe -q dm-crypt 2>/dev/null || true"
                    .into(),
            );
            part_cmds.push(format!(
                "cryptsetup luksFormat --type luks2 -q {root_part_path}"
            ));
            part_cmds.push("udevadm settle".into());
            part_cmds.push(format!(
                "cryptsetup open --type luks {root_part_path} cryptroot"
            ));
            part_cmds.push("mkfs.btrfs -f /dev/mapper/cryptroot".into());
        } else {
            part_cmds.push(format!("mkfs.btrfs -f {root_part_path}"));
        }
    }

    fn build_manual_partition_plan(state: &AppState, device: &str, part_cmds: &mut Vec<String>) {
        let label = state.disks_label.clone().unwrap_or_else(|| "gpt".into());
        if state.disks_wipe {
            part_cmds.push(format!("wipefs -a {device}"));
        }

        part_cmds.push(format!("parted -s {device} mklabel {label}"));
        part_cmds.push(format!("partprobe {device} || true"));
        part_cmds.push("udevadm settle".into());

        // Sort partitions by start position to ensure correct order
        let mut sorted_partitions = state.disks_partitions.clone();
        sorted_partitions.sort_by(|a, b| {
            let start_a = a
                .start
                .as_ref()
                .and_then(|s| s.parse::<u64>().ok())
                .unwrap_or(0);
            let start_b = b
                .start
                .as_ref()
                .and_then(|s| s.parse::<u64>().ok())
                .unwrap_or(0);
            start_a.cmp(&start_b)
        });

        let mut partition_number = 1;
        for spec in &sorted_partitions {
            // Skip partitions not for this device
            if let Some(spec_device) = &spec.name
                && spec_device != device
            {
                continue;
            }

            let role = spec.role.as_deref().unwrap_or("OTHER");
            let fs = spec.fs.as_deref().unwrap_or("ext4");
            let start = spec.start.as_deref().unwrap_or("0");
            let size = spec.size.as_deref().unwrap_or("100%");

            let start_str = crate::core::storage::bytes_to_parted_unit(start);
            let end_str = crate::core::storage::manual_disk_spec_end_for_parted(start, size)
                .unwrap_or_else(|_| crate::core::storage::bytes_to_parted_unit(size));

            // Create partition
            let part_type = match role {
                "BOOT" | "EFI" => "ESP",
                "SWAP" => "linux-swap",
                _ => "primary",
            };

            part_cmds.push(format!(
                "parted -s {device} mkpart {part_type} {fs} {start_str} {end_str}"
            ));

            // Set partition flags based on role
            match role {
                "BOOT" | "EFI" => {
                    part_cmds.push(format!("parted -s {device} set {partition_number} esp on"));
                }
                "BIOS_BOOT" => {
                    part_cmds.push(format!(
                        "parted -s {device} set {partition_number} bios_grub on"
                    ));
                }
                _ => {}
            }

            // Format the partition
            let partition_path = Self::get_partition_path(device, partition_number);
            match fs {
                "fat32" | "fat16" | "fat12" => {
                    let fat_type = match fs {
                        "fat32" => "32",
                        "fat16" => "16",
                        "fat12" => "12",
                        _ => "32",
                    };
                    part_cmds.push(format!("mkfs.fat -F {fat_type} {partition_path}"));
                }
                "linux-swap" => {
                    part_cmds.push(format!("mkswap {partition_path}"));
                }
                "btrfs" => {
                    part_cmds.push(format!("mkfs.btrfs -f {partition_path}"));
                }
                "ext4" => {
                    part_cmds.push(format!("mkfs.ext4 -F {partition_path}"));
                }
                "ext3" => {
                    part_cmds.push(format!("mkfs.ext3 -F {partition_path}"));
                }
                "ext2" => {
                    part_cmds.push(format!("mkfs.ext2 -F {partition_path}"));
                }
                "xfs" => {
                    part_cmds.push(format!("mkfs.xfs -f {partition_path}"));
                }
                "f2fs" => {
                    part_cmds.push(format!("mkfs.f2fs -f {partition_path}"));
                }
                _ => {
                    part_cmds.push(format!("mkfs.ext4 -F {partition_path}"));
                }
            }

            partition_number += 1;
        }

        part_cmds.push(format!("partprobe {device} || true"));
        part_cmds.push("udevadm settle".into());
    }

    fn get_partition_path(device: &str, partition_number: u32) -> String {
        // Handle devices that end with a digit (like /dev/nvme0n1)
        if device
            .chars()
            .last()
            .map(|c| c.is_ascii_digit())
            .unwrap_or(false)
        {
            format!("{device}p{partition_number}")
        } else {
            format!("{device}{partition_number}")
        }
    }

    pub fn execute_plan(plan: PartitionPlan) -> Result<(), String> {
        for c in plan.commands {
            let status = std::process::Command::new("bash")
                .arg("-lc")
                .arg(&c)
                .status();
            match status {
                Ok(st) if st.success() => {}
                Ok(_) => {
                    return Err(format!(
                        "Command failed: {}",
                        crate::common::utils::redact_command_for_logging(&c)
                    ));
                }
                Err(_) => {
                    return Err(format!(
                        "Failed to run: {}",
                        crate::common::utils::redact_command_for_logging(&c)
                    ));
                }
            }
        }
        Ok(())
    }
}