#!/usr/bin/env nix-shell
#!nix-shell -I nixpkgs=./. -i python3 -p common-updater-scripts gnused nix coreutils python312
"""
Updater script for the ocis_5-bin package.

This script fetches an HTML table from a specified URL and parses it to determine the release type
(either "Rolling" or "Production") of a given software version. It uses the built-in urllib.request
for fetching the HTML content and the built-in html.parser for parsing the HTML. By relying only on
standard library modules, we avoid dependencies on third-party libraries, which simplifies deployment
and improves portability.
"""
import urllib.request
import os
import subprocess
import json
import sys
from datetime import datetime
from html.parser import HTMLParser

TRACKING_CHANNEL = "Production"  # Either Rolling or Production

GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", None)

MAJOR_VERSION = 5
PKG_NAME = f"ocis_{MAJOR_VERSION}-5"

class TableParser(HTMLParser):
    def __init__(self, version):
        super().__init__()
        self.version = version
        self.in_td = False
        self.current_row = []
        self.release_type = None
        self.in_target_row = False

    def handle_starttag(self, tag, attrs):
        if tag == "td":
            self.in_td = True

        if tag == "a":
            href = dict(attrs).get("href", "")
            if self.version in href:
                self.in_target_row = True

    def handle_endtag(self, tag):
        if tag == "td":
            self.in_td = False

        if tag == "tr" and self.in_target_row:
            self.release_type = self.current_row[1]
            self.in_target_row = False

        if tag == "tr":
            self.current_row = []

    def handle_data(self, data):
        if self.in_td:
            self.current_row.append(data.strip())


def get_release_type(content, version):
    parser = TableParser(version)
    parser.feed(content)
    return parser.release_type


def get_all_versions():
    """Get versions from GitHub releases with pagination (up to 10 pages)."""
    versions = []
    page = 1
    max_pages = 10
    per_page = 30

    while page <= max_pages:
        url = f"https://api.github.com/repos/owncloud/ocis/releases?page={page}&per_page={per_page}"
        req = urllib.request.Request(url)

        if GITHUB_TOKEN:
            req.add_header("Authorization", f"Bearer {GITHUB_TOKEN}")

        req.add_header("Accept", "application/vnd.github.v3+json")
        req.add_header("User-Agent", "ocis-bin-updater-script")

        with urllib.request.urlopen(req) as response:
            if response.status != 200:
                raise Exception(f"HTTP request failed with status {response.status}")

            data = response.read()
            releases = json.loads(data)

            if not releases:
                break

            for release in releases:
                version = release["tag_name"].lstrip("v")
                published_date = datetime.strptime(
                    release["published_at"], "%Y-%m-%dT%H:%M:%SZ"
                )
                versions.append({"version": version, "published_date": published_date})

            page += 1

            if len(releases) < per_page:
                break

    if not versions:
        raise Exception("No releases found in GitHub API response")

    return versions


def get_current_version():
    result = subprocess.run(
        [
            "nix-instantiate",
            "--eval",
            "-E",
            f"with import ./. {{}}; {PKG_NAME}.version or (lib.getVersion {PKG_NAME})",
        ],
        capture_output=True,
        text=True,
    )
    result.check_returncode()
    return result.stdout.strip().strip('"')


def get_hash(os_name, arch, version):
    url = f"https://github.com/owncloud/ocis/releases/download/v{version}/ocis-{version}-{os_name}-{arch}"
    result = subprocess.run(
        ["nix-prefetch-url", "--type", "sha256", url], capture_output=True, text=True
    )
    result.check_returncode()
    pkg_hash = result.stdout.strip()
    result = subprocess.run(
        ["nix", "hash", "to-sri", f"sha256:{pkg_hash}"], capture_output=True, text=True
    )
    result.check_returncode()
    return result.stdout.strip()


def update_source_version(pkg_name, version, hash_value, system):
    subprocess.run(
        [
            "update-source-version",
            pkg_name,
            version,
            hash_value,
            f"--system={system}",
            "--ignore-same-version",
        ],
        check=True,
    )


def main():
    print("Fetching all versions from GitHub API (with pagination)...")
    all_versions = get_all_versions()
    print(f"Found {len(all_versions)} versions across multiple pages")

    if not all_versions:
        print("Error: No versions fetched from GitHub API")
        sys.exit(1)

    # We depend on the fact that versions are sorted reverse chronologically
    for version in all_versions:
        if version["version"].startswith(str(MAJOR_VERSION)):
            latest_version = version
            break
    print(f"Latest version from GitHub: {latest_version['version']}")

    nix_current_version = get_current_version()
    print(f"Current nix version: {nix_current_version}")

    current_version = None
    for version in all_versions:
        if nix_current_version == version["version"]:
            current_version = version
            break

    if not current_version:
        available_versions = [v["version"] for v in all_versions]
        print(
            f"Error: Cannot find GitHub release for current nix version {nix_current_version}"
        )
        print(
            f"Available versions (searched {len(available_versions)} across multiple pages): {', '.join(available_versions[:10])}..."
        )
        sys.exit(1)

    print(f"Found current version {current_version['version']} in GitHub releases")

    if current_version == latest_version:
        print(f"{PKG_NAME} is already up-to-date: {current_version['version']}")
        return

    print("Fetching release roadmap information...")
    roadmap_url = "https://owncloud.dev/ocis/release_roadmap/"
    try:
        response = urllib.request.urlopen(roadmap_url)
        content = response.read().decode("utf-8")

        latest_version_channel = get_release_type(content, latest_version["version"])
        current_version_channel = get_release_type(content, current_version["version"])

        print(
            f"Latest version {latest_version['version']} is in channel: {latest_version_channel}"
        )
        print(
            f"Current version {current_version['version']} is in channel: {current_version_channel}"
        )
    except Exception as e:
        print(f"Warning: Failed to fetch release roadmap information: {e}")
        print("Proceeding with update using latest version")
        latest_version_channel = TRACKING_CHANNEL
        current_version_channel = TRACKING_CHANNEL

    target_version = None
    if latest_version_channel == TRACKING_CHANNEL:
        target_version = latest_version
        print(
            f"Using latest version {latest_version['version']} as it is in the {TRACKING_CHANNEL} channel"
        )
    elif latest_version_channel != TRACKING_CHANNEL:
        print(f"Looking for a newer version in the {TRACKING_CHANNEL} channel...")
        for version in all_versions:
            try:
                channel = get_release_type(content, version["version"])
                if (
                    channel == TRACKING_CHANNEL
                    and version["published_date"] > current_version["published_date"]
                ):
                    target_version = version
                    print(
                        f"{PKG_NAME} found newer version {version['version']} in channel {TRACKING_CHANNEL}"
                    )
                    break
            except Exception as e:
                print(
                    f"Warning: Failed to determine channel for version {version['version']}: {e}"
                )

    if not target_version:
        print(
            f"{PKG_NAME} could not find newer version in {TRACKING_CHANNEL} than the current {current_version['version']}"
        )
        return

    print(
        f"Updating {PKG_NAME} from {current_version['version']} to {target_version['version']}"
    )

    systems = [
        ("darwin", "arm64", "aarch64-darwin"),
        ("linux", "arm64", "aarch64-linux"),
        ("linux", "arm", "armv7l-linux"),
        ("linux", "amd64", "x86_64-linux"),
        ("linux", "386", "i686-linux"),
    ]

    for os_name, arch, system in systems:
        print(f"Calculating hash for {os_name}-{arch}...")
        hash_value = get_hash(os_name, arch, target_version["version"])
        print(f"Updating package for {system}...")
        update_source_version(PKG_NAME, target_version["version"], hash_value, system)

    print(f"Successfully updated {PKG_NAME} to version {target_version['version']}")


if __name__ == "__main__":
    main()
