#!/usr/bin/env python3
"""massadb - discover and manage authorized Android devices over ADB."""

from __future__ import annotations

import argparse
import ipaddress
import math
import queue
import re
import shutil
import subprocess
import sys
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from typing import Callable, Iterable, TypeVar

from rich import box
from rich.console import Console
from rich.panel import Panel
from rich.progress import (
    Progress,
    ProgressColumn,
    SpinnerColumn,
    Task,
    TaskProgressColumn,
    TextColumn,
    TimeRemainingColumn,
)
from rich.prompt import Confirm
from rich.style import Style
from rich.table import Table
from rich.text import Text

console = Console()
T = TypeVar("T")


class GradientBarColumn(ProgressColumn):
    """A compact three-colour progress bar."""

    def __init__(self, width: int = 30) -> None:
        self.width = width
        super().__init__()

    def get_table_column(self):
        from rich.table import Column
        return Column(width=self.width)

    @staticmethod
    def _mix(a: tuple[int, int, int], b: tuple[int, int, int], t: float) -> tuple[int, int, int]:
        return tuple(round(x + (y - x) * t) for x, y in zip(a, b))

    def render(self, task: Task) -> Text:
        total = task.total or 1
        ratio = max(0.0, min(1.0, task.completed / total))
        filled = round(self.width * ratio)
        stops = ((255, 76, 124), (155, 92, 255), (0, 220, 255))
        bar = Text()

        for i in range(self.width):
            if i < filled:
                pos = i / max(1, self.width - 1)
                if pos <= 0.5:
                    rgb = self._mix(stops[0], stops[1], pos * 2)
                else:
                    rgb = self._mix(stops[1], stops[2], (pos - 0.5) * 2)
                colour = "#%02x%02x%02x" % rgb
                bar.append("━", style=Style(color=colour, bold=True))
            else:
                bar.append("─", style=Style(color="#343440"))
        return bar


def require_program(name: str) -> None:
    if shutil.which(name) is None:
        console.print(f"[bold red]Errore:[/] non trovo [cyan]{name}[/] nel PATH.")
        raise SystemExit(127)


def parallel_map(
    devices: list[str],
    jobs: int,
    description: str,
    worker: Callable[[str], T],
) -> list[tuple[str, T | Exception]]:
    """Run one operation per device, preserving the original device order."""
    if not devices:
        return []

    results: dict[str, T | Exception] = {}
    with Progress(
        SpinnerColumn(style="bright_magenta"),
        TextColumn("[bold]{task.description}[/]"),
        GradientBarColumn(26),
        TaskProgressColumn(),
        console=console,
        transient=True,
    ) as progress:
        task_id = progress.add_task(description, total=len(devices))
        with ThreadPoolExecutor(max_workers=min(jobs, len(devices))) as executor:
            futures = {executor.submit(worker, device): device for device in devices}
            for future in as_completed(futures):
                device = futures[future]
                try:
                    results[device] = future.result()
                except Exception as exc:
                    results[device] = exc
                progress.advance(task_id)

    return [(device, results[device]) for device in devices]


def result_output(result: subprocess.CompletedProcess[str]) -> str:
    parts = [result.stdout.strip(), result.stderr.strip()]
    output = "\n".join(part for part in parts if part)
    return output or "(nessun output)"


def validate_subnet(value: str) -> ipaddress.IPv4Network:
    try:
        network = ipaddress.ip_network(value, strict=False)
    except ValueError as exc:
        raise argparse.ArgumentTypeError(f"subnet non valida: {exc}") from exc

    if not isinstance(network, ipaddress.IPv4Network):
        raise argparse.ArgumentTypeError("per ora sono supportate solo subnet IPv4")

    private_ranges = (
        ipaddress.ip_network("10.0.0.0/8"),
        ipaddress.ip_network("172.16.0.0/12"),
        ipaddress.ip_network("192.168.0.0/16"),
    )
    if not any(network.subnet_of(private) for private in private_ranges):
        raise argparse.ArgumentTypeError("usa una subnet privata RFC1918 (10/8, 172.16/12 o 192.168/16)")
    if network.prefixlen < 24:
        raise argparse.ArgumentTypeError("limite di sicurezza: massimo una /24 (es. 192.168.1.0/24)")
    return network


def scan_adb(network: ipaddress.IPv4Network) -> list[str]:
    """Find hosts with TCP/5555 open, using Nmap's grepable output."""
    require_program("nmap")
    hosts_total = max(1, sum(1 for _ in network.hosts()))
    found: set[str] = set()
    events: queue.Queue[tuple[str, str | None]] = queue.Queue()

    command = [
        "nmap", "-n", "-v", "-p", "5555", "--open",
        "--reason", "--stats-every", "1s", "-oG", "-", str(network),
    ]
    console.print(Panel.fit(
        f"[bold]Subnet:[/] [cyan]{network}[/]\n[bold]Target stimati:[/] {hosts_total}\n[bold]Porta ADB:[/] TCP/5555",
        title="[bold bright_magenta]massadb · discovery[/]", border_style="bright_magenta"
    ))

    try:
        process = subprocess.Popen(
            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
            text=True, encoding="utf-8", errors="replace", bufsize=1,
        )
    except OSError as exc:
        console.print(f"[bold red]Impossibile avviare Nmap:[/] {exc}")
        raise SystemExit(1) from exc

    def pump(stream, name: str) -> None:
        assert stream is not None
        try:
            for line in iter(stream.readline, ""):
                events.put((name, line.rstrip("\r\n")))
        finally:
            stream.close()
            events.put((name, None))

    assert process.stdout is not None and process.stderr is not None
    threading.Thread(target=pump, args=(process.stdout, "stdout"), daemon=True).start()
    threading.Thread(target=pump, args=(process.stderr, "stderr"), daemon=True).start()

    done_streams = 0
    progress = Progress(
        SpinnerColumn(style="bright_magenta"),
        TextColumn("[bold]{task.description}[/]"),
        GradientBarColumn(30),
        TaskProgressColumn(),
        TimeRemainingColumn(),
        console=console,
        transient=False,
        expand=True,
    )

    with progress:
        task_id = progress.add_task("Nmap · inizializzazione", total=100)
        while done_streams < 2:
            try:
                stream_name, line = events.get(timeout=0.15)
            except queue.Empty:
                continue

            if line is None:
                done_streams += 1
                continue

            if stream_name == "stdout":
                match = re.search(r"\bHost:\s+(\d{1,3}(?:\.\d{1,3}){3}).*?\bPorts:\s*(.*)", line)
                if match and re.search(r"\b5555/open/tcp\b", match.group(2)):
                    found.add(match.group(1))
                    progress.update(task_id, description=f"Nmap · {len(found)} host ADB individuati")
            else:
                percent_match = re.search(r"About\s+([\d.]+)%\s+done", line)
                if percent_match:
                    percent = max(0.0, min(100.0, float(percent_match.group(1))))
                    remaining = math.ceil(hosts_total * (1.0 - percent / 100.0))
                    progress.update(
                        task_id,
                        completed=percent,
                        description=f"Subnet · ~{remaining} target rimanenti · {len(found)} ADB",
                    )
                if line.startswith(("Initiating ", "Scanning ", "Completed ", "Discovered ")):
                    progress.console.print(f"[dim]nmap:[/] {line}")

        return_code = process.wait()
        progress.update(task_id, completed=100, description="Scansione completata")
    if return_code != 0:
        console.print(f"[yellow]Nmap è terminato con codice {return_code}.[/]")
    return sorted(found, key=lambda item: tuple(int(part) for part in item.split(".")))


def adb_connect(addresses: Iterable[str], jobs: int = 8) -> int:
    require_program("adb")
    addresses = list(addresses)
    if not addresses:
        console.print("[yellow]Nessun host con TCP/5555 aperta trovato.[/]")
        return 0

    def connect_one(address: str) -> subprocess.CompletedProcess[str]:
        return subprocess.run(
            ["adb", "connect", f"{address}:5555"],
            capture_output=True, text=True, timeout=12,
        )

    results = parallel_map(addresses, jobs, "Connessione ADB", connect_one)
    table = Table(title="Dispositivi ADB trovati", box=box.ROUNDED, border_style="bright_cyan")
    table.add_column("Indirizzo", style="cyan")
    table.add_column("ADB", style="bold")
    failures = 0

    for address, result in results:
        if isinstance(result, Exception):
            message = str(result) or type(result).__name__
            ok = False
        else:
            message = (result.stdout or result.stderr).strip()
            ok = result.returncode == 0 and (
                "connected to" in message.lower() or "already connected" in message.lower()
            )
        if not ok:
            failures += 1
        table.add_row(
            f"{address}:5555",
            f"[green]{message or 'OK'}[/]" if ok else f"[red]{message or 'connessione fallita'}[/]",
        )

    console.print(table)
    show_devices()
    return 1 if failures else 0


def network_devices() -> list[str]:
    require_program("adb")
    result = subprocess.run(["adb", "devices"], capture_output=True, text=True)
    if result.returncode != 0:
        console.print(f"[red]{result.stderr.strip() or 'adb devices non riuscito'}[/]")
        return []

    serials: list[str] = []
    for line in result.stdout.splitlines()[1:]:
        parts = line.split()
        if len(parts) < 2 or parts[1] != "device" or ":" not in parts[0]:
            continue
        host, port = parts[0].rsplit(":", 1)
        if not port.isdigit():
            continue
        try:
            ip = ipaddress.ip_address(host)
        except ValueError:
            continue
        if isinstance(ip, ipaddress.IPv4Address):
            serials.append(parts[0])
    return sorted(set(serials))


def show_devices() -> list[str]:
    devices = network_devices()
    table = Table(title="Dispositivi connessi · ADB via rete", box=box.SIMPLE_HEAVY)
    table.add_column("#", style="dim", width=3)
    table.add_column("Serial", style="cyan")
    table.add_column("Stato", style="green")
    if devices:
        for index, serial in enumerate(devices, 1):
            table.add_row(str(index), serial, "device")
    else:
        table.add_row("—", "Nessun dispositivo", "[yellow]offline[/]")
    console.print(table)
    return devices


def reboot_devices(yes: bool = False, jobs: int = 8) -> int:
    devices = network_devices()
    if not devices:
        console.print("[yellow]Nessun dispositivo ADB via rete connesso.[/]")
        return 0

    console.print(f"Dispositivi da riavviare: [bold cyan]{len(devices)}[/]")
    for serial in devices:
        console.print(f"  • {serial}")
    if not yes and not Confirm.ask("Confermi il riavvio di tutti questi dispositivi?", default=False):
        console.print("[yellow]Operazione annullata.[/]")
        return 0

    def reboot_one(serial: str) -> subprocess.CompletedProcess[str]:
        return subprocess.run(["adb", "-s", serial, "reboot"], capture_output=True, text=True, timeout=30)

    results = parallel_map(devices, jobs, "Invio reboot", reboot_one)
    table = Table(title="Riavvio dispositivi", box=box.ROUNDED, border_style="bright_magenta")
    table.add_column("Dispositivo", style="cyan")
    table.add_column("Risultato")
    failures = 0

    for serial, result in results:
        if isinstance(result, Exception):
            failures += 1
            message = str(result) or type(result).__name__
            table.add_row(serial, f"[red]{message}[/]")
        elif result.returncode == 0:
            table.add_row(serial, "[green]comando inviato[/]")
        else:
            failures += 1
            table.add_row(serial, f"[red]{result_output(result)}[/]")
    console.print(table)
    return 1 if failures else 0


def shell_devices(command_parts: list[str], jobs: int = 8) -> int:
    if not command_parts:
        console.print("[red]Uso: massadb shell <comando>[/]")
        return 2
    devices = network_devices()
    if not devices:
        console.print("[yellow]Nessun dispositivo ADB via rete connesso.[/]")
        return 0

    command = " ".join(command_parts)
    console.print(Panel(f"[bold cyan]{command}[/]", title="Comando remoto", border_style="bright_magenta"))

    def shell_one(serial: str) -> subprocess.CompletedProcess[str]:
        return subprocess.run(
            ["adb", "-s", serial, "shell", command],
            capture_output=True, text=True, timeout=60,
        )

    results = parallel_map(devices, jobs, "Esecuzione sui dispositivi", shell_one)
    failures = 0
    for serial, result in results:
        if isinstance(result, subprocess.TimeoutExpired):
            output, code = "Comando scaduto dopo 60 secondi.", "timeout"
            style = "red"
        elif isinstance(result, Exception):
            output, code = str(result) or type(result).__name__, "errore"
            style = "red"
        else:
            output, code = result_output(result), str(result.returncode)
            style = "green" if result.returncode == 0 else "red"
            if result.returncode != 0:
                failures += 1
        if code != "0":
            failures += 1 if code == "timeout" or code == "errore" else 0
        console.print(Panel(
            Text(output),
            title=f"[bold cyan][{serial}][/bold cyan] Output",
            border_style=style,
            subtitle=f"exit code: {code}",
        ))
    return 1 if failures else 0


def pull_devices(remote_path: str, local_dir: str = "massadb-pull", jobs: int = 8) -> int:
    devices = network_devices()
    if not devices:
        console.print("[yellow]Nessun dispositivo ADB via rete connesso.[/]")
        return 0

    base_dir = Path(local_dir).expanduser()
    try:
        base_dir.mkdir(parents=True, exist_ok=True)
    except OSError as exc:
        console.print(f"[red]Impossibile creare {base_dir}:[/] {exc}")
        return 1

    def pull_one(serial: str) -> subprocess.CompletedProcess[str]:
        # Ogni device ha la propria cartella: nessun file viene sovrascritto da un altro device.
        device_dir = base_dir / serial.replace(":", "_")
        device_dir.mkdir(parents=True, exist_ok=True)
        return subprocess.run(
            ["adb", "-s", serial, "pull", remote_path, str(device_dir)],
            capture_output=True, text=True, timeout=600,
        )

    console.print(Panel(
        f"[bold cyan]Da:[/] {remote_path}\n[bold cyan]A:[/] {base_dir}/<serial>/",
        title="ADB pull", border_style="bright_magenta",
    ))
    results = parallel_map(devices, jobs, "Download dai dispositivi", pull_one)
    table = Table(title="Risultato pull", box=box.ROUNDED, border_style="bright_cyan")
    table.add_column("Dispositivo", style="cyan")
    table.add_column("Risultato")
    failures = 0

    for serial, result in results:
        if isinstance(result, Exception):
            failures += 1
            table.add_row(serial, f"[red]{str(result) or type(result).__name__}[/]")
        elif result.returncode == 0:
            table.add_row(serial, f"[green]{result_output(result)}[/]")
        else:
            failures += 1
            table.add_row(serial, f"[red]{result_output(result)}[/]")
    console.print(table)
    return 1 if failures else 0


def push_devices(local_path: str, remote_path: str, jobs: int = 8) -> int:
    source = Path(local_path).expanduser()
    if not source.exists():
        console.print(f"[red]Il file o la directory locale non esiste:[/] {source}")
        return 2

    devices = network_devices()
    if not devices:
        console.print("[yellow]Nessun dispositivo ADB via rete connesso.[/]")
        return 0

    console.print(Panel(
        f"[bold cyan]Da:[/] {source}\n[bold cyan]A:[/] {remote_path}",
        title="ADB push", border_style="bright_magenta",
    ))

    def push_one(serial: str) -> subprocess.CompletedProcess[str]:
        return subprocess.run(
            ["adb", "-s", serial, "push", str(source), remote_path],
            capture_output=True, text=True, timeout=600,
        )

    results = parallel_map(devices, jobs, "Upload sui dispositivi", push_one)
    table = Table(title="Risultato push", box=box.ROUNDED, border_style="bright_cyan")
    table.add_column("Dispositivo", style="cyan")
    table.add_column("Risultato")
    failures = 0

    for serial, result in results:
        if isinstance(result, Exception):
            failures += 1
            table.add_row(serial, f"[red]{str(result) or type(result).__name__}[/]")
        elif result.returncode == 0:
            table.add_row(serial, f"[green]{result_output(result)}[/]")
        else:
            failures += 1
            table.add_row(serial, f"[red]{result_output(result)}[/]")
    console.print(table)
    return 1 if failures else 0


def positive_int(value: str) -> int:
    try:
        number = int(value)
    except ValueError as exc:
        raise argparse.ArgumentTypeError("inserisci un numero intero") from exc
    if number < 1:
        raise argparse.ArgumentTypeError("-j deve essere almeno 1")
    return number


def add_jobs_argument(parser: argparse.ArgumentParser) -> None:
    parser.add_argument(
        "-j", "--jobs", type=positive_int, default=argparse.SUPPRESS,
        help="numero massimo di operazioni ADB simultanee (default: 8)",
    )


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="massadb",
        description="Discovery e gestione di dispositivi Android autorizzati tramite ADB.",
        epilog=(
            "Esempi: massadb connect 192.168.1.0/24 | massadb devices | "
            "massadb shell getprop ro.product.model | massadb pull /sdcard/Download | "
            "massadb push bootanimation.zip /sdcard/bootanimation.zip | massadb reboot"
        ),
    )
    parser.add_argument("-j", "--jobs", type=positive_int, default=8,
                        help="numero massimo di operazioni ADB simultanee (default: 8)")
    subparsers = parser.add_subparsers(dest="action", required=True)

    connect_parser = subparsers.add_parser("connect", help="cerca host ADB su una subnet privata e si connette")
    connect_parser.add_argument("subnet", type=validate_subnet, help="subnet IPv4 privata, massimo /24")
    add_jobs_argument(connect_parser)

    devices_parser = subparsers.add_parser("devices", help="mostra i dispositivi ADB via rete già connessi")
    add_jobs_argument(devices_parser)

    reboot_parser = subparsers.add_parser("reboot", help="riavvia tutti i dispositivi ADB via rete connessi")
    reboot_parser.add_argument("-y", "--yes", action="store_true", help="salta la conferma")
    add_jobs_argument(reboot_parser)

    shell_parser = subparsers.add_parser("shell", help="esegue un comando adb shell su ogni dispositivo connesso")
    add_jobs_argument(shell_parser)
    shell_parser.add_argument("command", nargs=argparse.REMAINDER, help="comando da eseguire")

    pull_parser = subparsers.add_parser("pull", help="scarica un percorso da tutti i dispositivi connessi")
    pull_parser.add_argument("remote", help="percorso remoto Android")
    pull_parser.add_argument("local", nargs="?", default="massadb-pull", help="cartella locale di destinazione (default: ./massadb-pull)")
    add_jobs_argument(pull_parser)

    push_parser = subparsers.add_parser("push", help="carica un file o una directory su tutti i dispositivi connessi")
    push_parser.add_argument("local", help="file o directory locale")
    push_parser.add_argument("remote", help="percorso remoto Android")
    add_jobs_argument(push_parser)

    return parser


def main() -> int:
    args = build_parser().parse_args()
    if args.action == "connect":
        addresses = scan_adb(args.subnet)
        if addresses:
            console.print(f"\n[bold green]Trovati {len(addresses)} host con ADB aperto.[/]")
            return adb_connect(addresses, args.jobs)
        console.print("\n[yellow]Nessun dispositivo con ADB TCP/5555 trovato.[/]")
    elif args.action == "devices":
        show_devices()
    elif args.action == "reboot":
        return reboot_devices(args.yes, args.jobs)
    elif args.action == "shell":
        return shell_devices(args.command, args.jobs)
    elif args.action == "pull":
        return pull_devices(args.remote, args.local, args.jobs)
    elif args.action == "push":
        return push_devices(args.local, args.remote, args.jobs)
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except KeyboardInterrupt:
        console.print("\n[yellow]Interrotto dall'utente.[/]")
        raise SystemExit(130)
