import requests
import json
import pprint
from datetime import datetime
from pytz import timezone    
import psycopg
from psycopg.rows import dict_row
import semver

class jru:

    def __init__(self):
        self.db_config = self._load_config_from_json("config.json")
        self.db_conn = self._db_connect(self.db_config)
    
    def _load_config_from_json(self,config_json_path):
        try:
            with open(config_json_path, "r") as f:
                conf = json.load(f)
        except Exception as json_err:
            print(json_err)
        return conf

    def _db_connect(self,db_config):
        try:
            conn = psycopg.connect(
            host=db_config['db']['server'],
            dbname=db_config['db']['name'],
            user=db_config['db']['login'],
            password=db_config['db']['password'])
            print('Connection to database is OK')
        except psycopg.OperationalError as connect_err:
            print('Error connecting to {}@{}'.format(db_config['db']['name'],db_config['db']['server']))
            print(connect_err)
            return 1
                
        return conn
    
    def _get_version_from_db(self,db_conn):
        cur = db_conn.cursor(row_factory=dict_row)
        qres = cur.execute("select * from jru.java_versions").fetchall()
        if qres:
            return qres
        else:
            return []
        
    
    def _get_version_semver_from_db(self,java_version):
        cur = self.db_conn.cursor(row_factory=dict_row)
        qres = cur.execute("select latest_release_packaged from jru.java_versions where java_version='{}'".format(java_version)).fetchall()
        if qres:
            return qres
        else:
            return []
        
    def _update_version_in_db(self,java_version,java_semver,update_timestampz):
        self.db_conn.execute("update jru.java_versions set latest_release_packaged = '{}',latest_release_packaged_timestamp = '{}' where java_version = '{}'".format(java_semver,update_timestampz,java_version))
        self.db_conn.commit()

    def _get_version_from_api(self):
        url = "https://api.adoptium.net/v3/info/available_releases"
        try:
            r = requests.get(url,headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36','Accept': 'application/json'})
            available_lts = r.json()["available_lts_releases"]
            available_lts_str = [str(i) for i in available_lts]    
        except Exception as err_json_request:
            print(err_json_request)
            r = {}
        return available_lts_str
        
    def _get_version_from_json(self):
        return self.db_config["java_settings"]["enabled_version"]
    
    def _get_latest_release_info(self,java_version,image_type="jre",arch="x64",os="linux"):
        # https://api.adoptium.net/v3/assets/latest/8/hotspot?architecture=x64&image_type=jre&os=linux&vendor=eclipse
        url = "https://api.adoptium.net/v3/assets/latest/{}/hotspot?architecture={}&image_type={}&os={}&vendor=eclipse".format(java_version,arch,image_type,os)
        try:
            print(" - requesting adoptium : {}".format(url))
            r = requests.get(url,headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36','Accept': 'application/json'})
        except Exception as err_json_request:
            print(err_json_request)
            r = {}
        return r.json()
    
    def run(self):
        print("Retrieve Java versions from DB : ")
        java_db_version = self._get_version_from_db(self.db_conn)
        java_db_version_list = [x["java_version"] for x in java_db_version]
        print("Retrieve Java versions from API : ")
        
        #java_config_version = self._get_version_from_json()
        java_config_version = self._get_version_from_api()
        
        # Inserting in database first time
        for json_vers in java_config_version:
            if json_vers not in java_db_version_list:
                print('- Java {} is not in database yet!'.format(json_vers))
                self.db_conn.execute("insert into jru.java_versions (java_version,latest_release_packaged) values ({},'{}.0.0')".format(json_vers,json_vers))
            else:
                print('- Java {} already found in database'.format(json_vers))
        self.db_conn.commit()
        
        #updating java_version from database
        java_db_version = self._get_version_from_db(self.db_conn)
        java_db_version_list = [x["java_version"] for x in java_db_version]
        
        update_timestampz = datetime.now(timezone("Europe/Paris"))
        
        for db_version in java_db_version_list:
            print("\nProcessing Java {}".format(db_version))
            api_version_info = self._get_latest_release_info(db_version)
            api_version_info_semver = api_version_info[0]["version"]["semver"]
            db_version_semver = self._get_version_semver_from_db(db_version)[0]["latest_release_packaged"]
            if semver.VersionInfo.parse(api_version_info_semver) > semver.VersionInfo.parse(db_version_semver):
                print(" - New version available! - {} > {}".format(api_version_info_semver,db_version_semver))
                self._update_version_in_db(db_version,api_version_info_semver,update_timestampz)
            else:
                print(' - No upgrade needed! API {} == DB {}'.format(api_version_info_semver,db_version_semver))
        
if __name__ == "__main__":
    jru_main = jru()
    jru_main.run()