import hashlib, logging, os, re
import jinja2 as j2
import os.path as path
import requests as r
import yaml

from .git import get_tag_from_git

class Package(object):
    def __init__(self, name, **params):
        self.name = name
        self.repo = params.get("repo")
        self.tag = params.get("tag") or get_tag_from_git(self.repo)
        self.force = params.get("force", False)
        self.render = params.get("render", True)
        self.maintainers = params.get("maintainers", {})
        self.contributors = params.get("contributors", {})
        self.build = False
        self.ignore = params.get("ignore", False)
        logging.debug(self)

    @property
    def template(self):
        return self.name + ".j2"

    def __repr__(self):
        return f"{self.name} [repo: {self.repo}, tag: {self.tag}, force: {self.force}]"

    def load(config, repository):
        with open(path.join(config.dir, "packages.yaml")) as file:
            p_list = yaml.load(file, Loader=yaml.SafeLoader)

        packages = []
        for p in p_list:
            package = Package(**p)
            package.pkgbuild = path.join(config.dir, f"pkgbuilds/{package.name}.j2")
            packages.append(package)

            current_version, current_rev = repository.get_package_version(package.name)

            if package.tag > current_version:
                package.rel = 1
                package.build = True
            elif package.force:
                package.rel = current_rev + 1
                package.build = True
            else:
                package.rel = current_rev

            if package.build:
                logging.info(f"{package.name} will be updated ({current_version}-{current_rev} → {package.tag}-{package.rel})")
            else:
                logging.info(f"{package.name} will be skipped")

        logging.info(f"{len(packages)} packages loaded")

        return packages

    def get_source_hash(self, config):
        regex = re.compile("^source=.+(https?://.+\.tar\.[a-z]+)", re.MULTILINE)
        with open(path.join(config.dir, "pkgbuilds", self.template)) as file:
            content = file.read()
        try:
            url = regex.search(content).group(1)
        except:
            logging.warning(f"cannot find valid source for {self.name} (is it a git version?)")
            return "SKIP"
        url = url.replace("${pkgver}", self.tag)
        url = url.replace("${pkgname}", self.name)

        try:
            archive = r.get(url, timeout=10)
        except Exception as e:
            logging.warning(f"cannot retreive {url}")
            logging.debug(e)
            return "SKIP"

        hash = hashlib.sha256(archive.content).hexdigest()
        return hash

    def render_pkgbuild(self, config):
        env = j2.Environment(
            loader=j2.FileSystemLoader(path.join(config.dir, "pkgbuilds")),
            autoescape=j2.select_autoescape([])
        )
        template = env.get_template(self.template)
        hash = self.get_source_hash(config)

        sysenv = j2.Environment(
            loader=j2.FileSystemLoader('middlearch'),
            autoescape=j2.select_autoescape([])
        )
        maintainers_template = sysenv.get_template("maintainers.j2")

        dest_dir = path.join(config.get('output'), self.name)
        dest_file = path.join(dest_dir, "PKGBUILD")
        os.makedirs(dest_dir, exist_ok=True)

        with open(dest_file, "w") as file:
            file.write(maintainers_template.render(
                maintainers=self.maintainers,
                contributors=self.contributors
            ))
            file.write(template.render(name=self.name, tag=self.tag, rel=self.rel, hash=hash))