#!/usr/bin/env python3

import os
import platform
import shutil
import subprocess
import sys

from pythonforandroid.logger import info, warning, error
from pythonforandroid.util import ensure_dir


class Prerequisite(object):
 name = "Default"
 homebrew_formula_name = ""
 mandatory = dict(linux=False, darwin=False)
 installer_is_supported = dict(linux=False, darwin=False)

 def is_valid(self):
 if self.checker():
 info(f"Prerequisite {self.name} is met")
 return (True, "")
 elif not self.mandatory[sys.platform]:
 warning(
 f"Prerequisite {self.name} is not met, but is marked as non-mandatory"
 )
 else:
 error(f"Prerequisite {self.name} is not met")

 def checker(self):
 if sys.platform == "darwin":
 return self.darwin_checker()
 elif sys.platform == "linux":
 return self.linux_checker()
 else:
 raise Exception("Unsupported platform")

 def ask_to_install(self):
 if (
 os.environ.get("PYTHONFORANDROID_PREREQUISITES_INSTALL_INTERACTIVE", "1")
 == "1"
 ):
 res = input(
 f"Do you want automatically install prerequisite {self.name}? [y/N] "
 )
 if res.lower() == "y":
 return True
 else:
 return False
 else:
 info(
 "Session is not interactive (usually this happens during a CI run), so let's consider it as a YES"
 )
 return True

 def install(self):
 info(f"python-for-android can automatically install prerequisite: {self.name}")
 if self.ask_to_install():
 if sys.platform == "darwin":
 self.darwin_installer()
 elif sys.platform == "linux":
 self.linux_installer()
 else:
 raise Exception("Unsupported platform")
 else:
 info(
 f"Skipping installation of prerequisite {self.name} as per user request"
 )

 def show_helper(self):
 if sys.platform == "darwin":
 self.darwin_helper()
 elif sys.platform == "linux":
 self.linux_helper()
 else:
 raise Exception("Unsupported platform")

 def install_is_supported(self):
 return self.installer_is_supported[sys.platform]

 def linux_checker(self):
 raise Exception(f"Unsupported prerequisite check on linux for {self.name}")

 def darwin_checker(self):
 raise Exception(f"Unsupported prerequisite check on macOS for {self.name}")

 def linux_installer(self):
 raise Exception(f"Unsupported prerequisite installer on linux for {self.name}")

 def darwin_installer(self):
 raise Exception(f"Unsupported prerequisite installer on macOS for {self.name}")

 def darwin_helper(self):
 info(f"No helper available for prerequisite: {self.name} on macOS")

 def linux_helper(self):
 info(f"No helper available for prerequisite: {self.name} on linux")

 def _darwin_get_brew_formula_location_prefix(self, formula, installed=False):
 opts = ["--installed"] if installed else []
 p = subprocess.Popen(
 ["brew", "--prefix", formula, *opts],
 stdout=subprocess.PIPE,
 stderr=subprocess.PIPE,
 )
 _stdout_res, _stderr_res = p.communicate()

 if p.returncode != 0:
 error(_stderr_res.decode("utf-8").strip())
 return None
 else:
 return _stdout_res.decode("utf-8").strip()

 def darwin_pkg_config_location(self):
 warning(
 f"pkg-config location is not supported on macOS for prerequisite: {self.name}"
 )
 return ""

 def linux_pkg_config_location(self):
 warning(
 f"pkg-config location is not supported on linux for prerequisite: {self.name}"
 )
 return ""

 @property
 def pkg_config_location(self):
 if sys.platform == "darwin":
 return self.darwin_pkg_config_location()
 elif sys.platform == "linux":
 return self.linux_pkg_config_location()


class HomebrewPrerequisite(Prerequisite):
 name = "homebrew"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=False)

 def darwin_checker(self):
 return shutil.which("brew") is not None

 def darwin_helper(self):
 info(
 "Installer for homebrew is not yet supported on macOS,"
 "the nice news is that the installation process is easy!"
 "See: https://brew.sh for further instructions."
 )


class JDKPrerequisite(Prerequisite):
 name = "JDK"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)
 supported_version = 17

 def darwin_checker(self):
 if "JAVA_HOME" in os.environ:
 info("Found JAVA_HOME environment variable, using it")
 jdk_path = os.environ["JAVA_HOME"]
 else:
 jdk_path = self._darwin_get_libexec_jdk_path(version=None)
 return self._darwin_jdk_is_supported(jdk_path)

 def _darwin_get_libexec_jdk_path(self, version=None):
 version_args = []
 if version is not None:
 version_args = ["-v", version]
 return (
 subprocess.run(
 ["/usr/libexec/java_home", *version_args],
 stdout=subprocess.PIPE,
 )
 .stdout.strip()
 .decode()
 )

 def _darwin_jdk_is_supported(self, jdk_path):
 if not jdk_path:
 return False

 javac_bin = os.path.join(jdk_path, "bin", "javac")
 if not os.path.exists(javac_bin):
 return False

 p = subprocess.Popen(
 [javac_bin, "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
 )
 _stdout_res, _stderr_res = p.communicate()

 if p.returncode != 0:
 error("Failed to run javac to check JDK version")
 return False

 if not _stdout_res:
 _stdout_res = _stderr_res

 res = _stdout_res.strip().decode()

 major_version = int(res.split(" ")[-1].split(".")[0])
 if major_version == self.supported_version:
 info(f"Found a valid JDK at {jdk_path}")
 return True
 else:
 error(f"JDK version {major_version} is not supported")
 return False

 def darwin_helper(self):
 info(
 f"python-for-android requires a JDK {self.supported_version} to be installed on macOS,"
 "but seems like you don't have one installed."
 )
 info(
 "If you think that a valid JDK is already installed, please verify that "
 f"you have a JDK {self.supported_version} installed and that `/usr/libexec/java_home` "
 "shows the correct path."
 )
 info(
 "If you have multiple JDK installations, please make sure that you have "
 "`JAVA_HOME` environment variable set to the correct JDK installation."
 )

 def darwin_installer(self):
 info(
 f"Looking for a JDK {self.supported_version} installation which is not the default one ..."
 )
 jdk_path = self._darwin_get_libexec_jdk_path(version=str(self.supported_version))

 if not self._darwin_jdk_is_supported(jdk_path):
 info(f"We're unlucky, there's no JDK {self.supported_version} or higher installation available")

 base_url = "https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.2%2B8/"
 if platform.machine() == "arm64":
 filename = "OpenJDK17U-jdk_aarch64_mac_hotspot_17.0.2_8.tar.gz"
 else:
 filename = "OpenJDK17U-jdk_x64_mac_hotspot_17.0.2_8.tar.gz"

 info(f"Downloading {filename} from {base_url}")
 subprocess.check_output(
 [
 "curl",
 "-L",
 f"{base_url}{filename}",
 "-o",
 f"/tmp/{filename}",
 ]
 )

 user_library_java_path = os.path.expanduser(
 "~/Library/Java/JavaVirtualMachines"
 )
 info(f"Extracting {filename} to {user_library_java_path}")
 ensure_dir(user_library_java_path)
 subprocess.check_output(
 ["tar", "xzf", f"/tmp/{filename}", "-C", user_library_java_path],
 )

 jdk_path = self._darwin_get_libexec_jdk_path(version="17.0.2+8")

 info(f"Setting JAVA_HOME to {jdk_path}")
 os.environ["JAVA_HOME"] = jdk_path


class OpenSSLPrerequisite(Prerequisite):
 name = "openssl"
 homebrew_formula_name = "openssl@1.1"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix(
 self.homebrew_formula_name, installed=True
 )
 is not None
 )

 def darwin_pkg_config_location(self):
 return os.path.join(
 self._darwin_get_brew_formula_location_prefix(self.homebrew_formula_name),
 "lib/pkgconfig",
 )

 def darwin_installer(self):
 info("Installing OpenSSL ...")
 subprocess.check_output(["brew", "install", self.homebrew_formula_name])


class AutoconfPrerequisite(Prerequisite):
 name = "autoconf"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix("autoconf", installed=True)
 is not None
 )

 def darwin_installer(self):
 info("Installing Autoconf ...")
 subprocess.check_output(["brew", "install", "autoconf"])


class AutomakePrerequisite(Prerequisite):
 name = "automake"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix("automake", installed=True)
 is not None
 )

 def darwin_installer(self):
 info("Installing Automake ...")
 subprocess.check_output(["brew", "install", "automake"])


class LibtoolPrerequisite(Prerequisite):
 name = "libtool"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix("libtool", installed=True)
 is not None
 )

 def darwin_installer(self):
 info("Installing Libtool ...")
 subprocess.check_output(["brew", "install", "libtool"])


class PkgConfigPrerequisite(Prerequisite):
 name = "pkg-config"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix("pkg-config", installed=True)
 is not None
 )

 def darwin_installer(self):
 info("Installing Pkg-Config ...")
 subprocess.check_output(["brew", "install", "pkg-config"])


class CmakePrerequisite(Prerequisite):
 name = "cmake"
 mandatory = dict(linux=False, darwin=True)
 installer_is_supported = dict(linux=False, darwin=True)

 def darwin_checker(self):
 return (
 self._darwin_get_brew_formula_location_prefix("cmake", installed=True)
 is not None
 )

 def darwin_installer(self):
 info("Installing cmake ...")
 subprocess.check_output(["brew", "install", "cmake"])


def get_required_prerequisites(platform="linux"):
 return [
 prerequisite_cls()
 for prerequisite_cls in [
 HomebrewPrerequisite,
 AutoconfPrerequisite,
 AutomakePrerequisite,
 LibtoolPrerequisite,
 PkgConfigPrerequisite,
 CmakePrerequisite,
 OpenSSLPrerequisite,
 JDKPrerequisite,
 ] if prerequisite_cls.mandatory.get(platform, False)
 ]


def check_and_install_default_prerequisites():

 prerequisites_not_met = []

 warning(
 "prerequisites.py is experimental and does not support all prerequisites yet."
 )
 warning("Please report any issues to the python-for-android issue tracker.")

 # Phase 1: Check if all prerequisites are met and add the ones
 # which are not to `prerequisites_not_met`
 for prerequisite in get_required_prerequisites(sys.platform):
 if not prerequisite.is_valid():
 prerequisites_not_met.append(prerequisite)

 # Phase 2: Setup/Install all prerequisites that are not met
 # (where possible), otherwise show an helper.
 for prerequisite in prerequisites_not_met:
 prerequisite.show_helper()
 if prerequisite.install_is_supported():
 prerequisite.install()


if __name__ == "__main__":
 check_and_install_default_prerequisites()