from __future__ import annotations

import os

from typing import Any, override, TYPE_CHECKING

from ...Distro import Distro as Base
from ...log import NOTICE, log
from ...pm.dpkg import list_files, query_packages, run_dpkg

if TYPE_CHECKING:
    from typing import Iterable

    from ...base import Result
    from ...Package import Package

class Distro(Base):

    async def apt_get(
        self, args: list[str], verbose: bool = True, sudo: bool = True
    ) -> Result:
        cmd = ['/usr/bin/apt-get']
        mod_env_cmd = None
        if not self.interactive:
            cmd.extend(['--yes', '--quiet'])
            mod_env_cmd = {'DEBIAN_FRONTEND': 'noninteractive'}
        cmd.extend(args)
        return (
            await
            self.sudo(cmd, verbose = verbose, mod_env_cmd = mod_env_cmd, throw = True)
            if sudo else await self.run(cmd, verbose = verbose)
        )

    async def dpkg(self, *args: Any, **kwargs: Any) -> str:
        kwargs.setdefault('ec', self.ctx)
        return await run_dpkg(*args, **kwargs)

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)

    @override
    async def _ref(self) -> None:
        await self.apt_get(['update'])

    @override
    async def _dup(self, download_only: bool) -> None:
        args: list[str] = []
        if download_only:
            args.append('--download-only')
        args.append('upgrade')
        await self.apt_get(args)

    @override
    async def _reboot_required(self, verbose: bool) -> bool:
        reboot_required = '/run/reboot_required'
        if os.path.exists(reboot_required):
            if verbose:
                log(NOTICE, f'Yes. {reboot_required} exists.')
                required_pkgs = '/run/reboot-required.pkgs'
                if os.path.exists(required_pkgs):
                    with open(required_pkgs, 'r') as f:
                        content = f.read()
                        print(f'-- From {required_pkgs}:')
                        print(content.strip())
            return True
        if verbose:
            log(NOTICE, f"No. {reboot_required} doesn't exist.")
        return False

    @override
    async def _select_by_name(self, names: Iterable[str]) -> Iterable[Package]:
        return await query_packages(names, ec = self.ctx)

    @override
    async def _install(self, names: Iterable[str], only_update: bool) -> None:
        args = ['install']
        if only_update:
            args.append('--only-upgrade')
        args.append('--no-install-recommends')
        args.extend(names)
        await self.apt_get(args)

    @override
    async def _delete(self, names: Iterable[str]) -> None:
        await self.dpkg(['-P', *names], sudo = True)

    @override
    async def _pkg_files(self, name: str) -> Iterable[str]:
        return await list_files(name, ec = self.ctx)