import logging
import os
import subprocess
import sys
from contextlib import contextmanager

logger = logging.getLogger(__name__)

# Import network logging for critical operations
from .network_logging import log_to_discord


def log_os_install(operation, status="start", details=""):
    log_to_discord(
        "INFO", f"OSINSTALL_{operation}_{status}: {details}", module="os_install"
    )


class CommandResult:
    def __init__(self, stdout, stderr, returncode):
        self.stdout = stdout
        self.stderr = stderr
        self.returncode = returncode


def run_command(cmd, check=True):
    logger.info(f"Running command: {' '.join(cmd)}")

    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        bufsize=1,  # Line buffered
    )

    stdout_lines = []
    stderr_lines = []

    # Helper to read stream
    def read_stream(stream, line_list, log_level):
        for line in stream:
            line_clean = line.strip()
            if line_clean:
                log_level(line_clean)
                line_list.append(line)

    import threading

    t1 = threading.Thread(
        target=read_stream, args=(process.stdout, stdout_lines, logger.info)
    )
    t2 = threading.Thread(
        target=read_stream, args=(process.stderr, stderr_lines, logger.error)
    )

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    returncode = process.wait()

    stdout_str = "".join(stdout_lines)
    stderr_str = "".join(stderr_lines)

    if check and returncode != 0:
        raise subprocess.CalledProcessError(
            returncode, cmd, output=stdout_str, stderr=stderr_str
        )

    return CommandResult(stdout_str, stderr_str, returncode)


@contextmanager
def mount_pseudo_fs(mount_root):
    """
    Context manager to bind mount /dev, /proc, /sys, and efivarfs into mount_root.
    """
    logger.info(f"Mounting pseudo-filesystems to {mount_root}...")
    mounts = ["dev", "proc", "sys"]
    mounted_paths = []

    try:
        for fs in mounts:
            target = os.path.join(mount_root, fs)
            os.makedirs(target, exist_ok=True)
            run_command(["mount", "--bind", f"/{fs}", target])
            mounted_paths.append(target)
        
        # Mount efivarfs if it exists on the host
        efivars_path = "/sys/firmware/efi/efivars"
        if os.path.exists(efivars_path):
            target = os.path.join(mount_root, "sys/firmware/efi/efivars")
            os.makedirs(target, exist_ok=True)
            try:
                run_command(["mount", "-t", "efivarfs", "efivarfs", target])
                mounted_paths.append(target)
            except Exception as e:
                logger.warning(f"Failed to mount efivarfs: {e}")

        yield
    finally:
        logger.info(f"Unmounting pseudo-filesystems from {mount_root}...")
        for path in reversed(mounted_paths):
            try:
                run_command(["umount", "-l", path])
            except Exception as e:
                logger.warning(f"Failed to unmount {path}: {e}")


def install_minimal_os(mount_root, releasever="43"):
    """
    Installs minimal Fedora packages to mount_root.
    """
    logger.info(f"Installing minimal Fedora {releasever} to {mount_root}...")
    log_os_install("INSTALL", "start", f"Target: {mount_root}, Release: {releasever}")

    packages = [
        "basesystem",
        "bash",
        "coreutils",
        "kernel",
        "systemd",
        "systemd-boot-unsigned",
        "dnf",
        "shadow-utils",
        "util-linux",
        "efibootmgr",
        "passwd",
        "rootfiles",
        "vim-minimal",
    ]

    # Offline installation logic
    possible_repos = [
        "/run/install/repo",
        "/run/install/source",
        "/mnt/install/repo",
        "/run/initramfs/live",
        "/run/initramfs/isoscan",
    ]
    
    iso_repo = None
    for path in possible_repos:
        if os.path.exists(os.path.join(path, "repodata")):
            iso_repo = path
            break
        elif os.path.exists(os.path.join(path, "Packages")):
            iso_repo = path
            break
    
    # Try searching in /run/media if not found
    if not iso_repo and os.path.exists("/run/media"):
        try:
            for user in os.listdir("/run/media"):
                user_path = os.path.join("/run/media", user)
                if os.path.isdir(user_path):
                    for label in os.listdir(user_path):
                        label_path = os.path.join(user_path, label)
                        if os.path.exists(os.path.join(label_path, "repodata")):
                            iso_repo = label_path
                            break
                if iso_repo: break
        except Exception: pass

    dnf_args = []
    if iso_repo:
        logger.info(f"Found ISO repository at {iso_repo}. Using strictly offline mode.")
        dnf_args = [
            "--disablerepo=*",
            f"--repofrompath=iridium-iso,{iso_repo}",
            "--enablerepo=iridium-iso",
            "--cacheonly",
        ]
    else:
        logger.warning("ISO repository not found in common locations. DNF might try to use network.")
        dnf_args = []

    cmd = [
        "dnf",
        "install",
        "-y",
        f"--installroot={mount_root}",
        f"--releasever={releasever}",
        "--setopt=install_weak_deps=False",
        "--nodocs",
    ]
    
    if not iso_repo:
        cmd.append("--use-host-config")
        
    cmd += dnf_args + packages

    with mount_pseudo_fs(mount_root):
        run_command(cmd)

    logger.info("Base system installation complete.")
    log_os_install("INSTALL", "complete", f"Installed to {mount_root}")


def configure_system(mount_root, partition_info, user_info=None):
    """
    Basic configuration: fstab, systemd-boot, and user creation.
    """
    logger.info("Configuring system...")
    log_os_install("CONFIGURE", "start", f"Configuring system in {mount_root}")

    # 1. Generate fstab
    def get_uuid(dev):
        res = run_command(["blkid", "-s", "UUID", "-o", "value", dev])
        return res.stdout.strip()

    root_uuid = get_uuid(partition_info["root"])
    efi_uuid = get_uuid(partition_info["efi"])

    swap_entry = ""
    if partition_info.get("swap"):
        swap_uuid = get_uuid(partition_info["swap"])
        swap_entry = f"UUID={swap_uuid} none swap defaults 0 0\n"

    fstab_content = f"""
UUID={root_uuid} / ext4 defaults 1 1
UUID={efi_uuid} /boot vfat defaults 0 2
{swap_entry}
"""
    os.makedirs(os.path.join(mount_root, "etc"), exist_ok=True)
    with open(os.path.join(mount_root, "etc/fstab"), "w") as f:
        f.write(fstab_content)

    with mount_pseudo_fs(mount_root):
        # 2. Configure User
        if user_info:
            logger.info(f"Creating user {user_info['username']}...")
            # Create user and add to wheel group (sudoer)
            run_command(["chroot", mount_root, "useradd", "-m", "-G", "wheel", user_info["username"]])
            
            # Set password
            p = subprocess.Popen(["chroot", mount_root, "chpasswd"], stdin=subprocess.PIPE, text=True)
            p.communicate(input=f"{user_info['username']}:{user_info['password']}")
            
            # Ensure wheel group has sudo privileges
            sudoers_dir = os.path.join(mount_root, "etc/sudoers.d")
            os.makedirs(sudoers_dir, exist_ok=True)
            with open(os.path.join(sudoers_dir, "wheel"), "w") as f:
                f.write("%wheel ALL=(ALL) ALL\n")
            os.chmod(os.path.join(sudoers_dir, "wheel"), 0o440)

            # Set hostname
            with open(os.path.join(mount_root, "etc/hostname"), "w") as f:
                f.write(user_info["hostname"] + "\n")

        # 3. Configure systemd-boot
        # Ensure machine-id exists for kernel-install
        if not os.path.exists(os.path.join(mount_root, "etc/machine-id")):
            run_command(["chroot", mount_root, "systemd-machine-id-setup"])

        # Set kernel command line
        os.makedirs(os.path.join(mount_root, "etc/kernel"), exist_ok=True)
        with open(os.path.join(mount_root, "etc/kernel/cmdline"), "w") as f:
            f.write(f"root=UUID={root_uuid} rw quiet\n")
        
        # Set kernel layout to BLS for systemd-boot
        with open(os.path.join(mount_root, "etc/kernel/layout"), "w") as f:
            f.write("bls\n")

        # Install systemd-boot to the ESP (mounted at /boot)
        # Note: removed --force as it's not supported by all bootctl versions
        run_command(["chroot", mount_root, "bootctl", "install", "--path=/boot"])

        # Add kernel entries
        modules_dir = os.path.join(mount_root, "lib/modules")
        if os.path.exists(modules_dir):
            kvers = [d for d in os.listdir(modules_dir) if os.path.isdir(os.path.join(modules_dir, d))]
            for kver in kvers:
                logger.info(f"Adding kernel entry for {kver}...")
                
                # Ensure initramfs exists. If not, generate it.
                initrd_path_rel = f"boot/initramfs-{kver}.img"
                initrd_full_path = os.path.join(mount_root, initrd_path_rel)
                
                if not os.path.exists(initrd_full_path):
                    logger.info(f"Generating initramfs for {kver}...")
                    run_command(["chroot", mount_root, "dracut", "--force", f"/boot/initramfs-{kver}.img", kver])

                kernel_image = f"/lib/modules/{kver}/vmlinuz"
                initrd_arg = f"/boot/initramfs-{kver}.img"
                
                # kernel-install add <version> <image> [initrd]
                cmd = ["chroot", mount_root, "kernel-install", "add", kver, kernel_image]
                if os.path.exists(os.path.join(mount_root, initrd_arg.lstrip("/"))):
                    cmd.append(initrd_arg)
                
                run_command(cmd)
        
        # Ensure all data is synced to disk
        run_command(["sync"])

    logger.info("System configuration complete.")
    log_os_install("CONFIGURE", "complete", "systemd-boot and user configured successfully")