import glob
import sys
import itertools
import jinja2
import re
import yaml
import os
from nested_lookup import nested_lookup
from pathlib import Path

# defines
METRIC_KEYS = 4
SLOS_FOLDER_BASENAME = os.path.basename("slos")
OUTPUT_FOLDER_BASENAME = os.path.basename("output")
TEMPLATE_FOLDER_BASENAME = os.path.basename("templates")
TEMPLATE_FILES = {
    "terraform-template.j2":["builtin:service.keyRequest.errors.fivexx.rate"],
    "terraform-template-2.j2":["builtin:service.keyRequest.errors.server.successCount",
                               "builtin:service.keyRequest.count.server"],
    "terraform-template-3.j2":["builtin:service.keyRequest.errors.fivexx.count",
                               "builtin:service.keyRequest.count.server"],
    "terraform-template-4.j2":["builtin:service.successes.server.rate"],
    "terraform-template-5.j2":["calc:service.vehicleservice_oes_responsecode_998_requestcount",
                               "calc:service.vehicleservice_oes_responsecode_999_requestcount",
                               "calc:service.vehicleservice_oes_fivexx_count",
                               "calc:service.vehicleservice_oes_request_count_total"]
}
FOLDERS = {"My Journey":"DE-3",
           "Connected Vehicle Platforms":"DE-7",
           "My Life":"DE-4",
           "China Services":"EC-DE"}

# methods
def homogenize_keyRequests(keyRequests):
    for metric in metrics:
        if len(metrics) < METRIC_KEYS:
            metrics.append('')
    return metrics

def homogenize_services(services):
    for metric in metrics:
        if len(metrics) < METRIC_KEYS:
            metrics.append('')
    return metrics

def homogenize_metrics(metrics):
    for metric in metrics:
        if len(metrics) < METRIC_KEYS:
            metrics.append('')
    return metrics


def template_logic(metrics,TEMPLATE_FILES):
    for template,metric in TEMPLATE_FILES.items():
        if set(metrics) == set(metric):
            return template
    print("Problem occured while matching metric: Exiting program...")
    sys.exit(0)

# main
def main(configFile):
    slo_id = None
    slo_name = None
    module_name = None
    displayname = None
    department = None
    description = None
    doc_url = None
    slo_definition_tresholds_warning = None
    slo_definition_tresholds_failure = None
    metrics = {}
    services = {}
    keyRequests = {}
    environments = {}

    try:
        # read yaml file
        with open(configFile) as cF:
            slos = list(yaml.safe_load_all(cF))
    except EnvironmentError:
        print('Corrupt yaml file:' + str(configFile))

    # fill values
    for slo in slos:
        slo_id = slo["slo_id"]
        slo_name = slo["slo_name"]
        module_name = slo_name
        displayname = slo["displayname"]
        description = slo["description"]
        department = slo["department"]
        doc_url = slo["doc_url"]
        slo_definition_tresholds_warning = slo["slo_definition"]["tresholds"]["warning"]
        slo_definition_tresholds_failure = slo["slo_definition"]["tresholds"]["failure"]
        slo["slo_definition"].pop("tresholds")

    for env in slo["slo_definition"]:
        if "EMEA-Prod" in slo["slo_definition"]:
            environments["EMEA-Prod"] = slo["slo_definition"][env]
        if "NA-Prod" in slo["slo_definition"]:
            environments["NA-Prod"] = slo["slo_definition"][env]
        if "CN-Prod" in slo["slo_definition"]:
            environments["CN-Prod"] = slo["slo_definition"][env]

    # for environment in environments:
    #     metrics[environment] = nested_lookup('metric',slo["slo_definition"][environment])        
        
    #     for m,metric in enumerate(metrics):
    #         services[metric] = '~",\n\t\t\t\t~"'.join(nested_lookup('service',slo["slo_definition"][environment][m]["filter"]))

    #     keyRequests[environment] = nested_lookup('keyRequests',slo["slo_definition"][environment])
    #     keyRequests[environment] = '~",\n\t\t\t\t~"'.join(itertools.chain.from_iterable(keyRequests[environment]))
    

    # read template file
    jinja_environment = jinja2.Environment(loader=jinja2.FileSystemLoader(TEMPLATE_FOLDER_BASENAME),
                                           trim_blocks=True,
                                           lstrip_blocks=True)

    # generate terraform file
    for environment in environments:
        folder_path = os.path.join(cwd,OUTPUT_FOLDER_BASENAME,environment.replace('-','_'),"slo")
        if not os.path.exists(folder_path):
            os.makedirs(folder_path)
        with open(os.path.join(folder_path,module_name+".tf"),"w+") as file:
            t = template_logic(nested_lookup('metric',environments[environment]),TEMPLATE_FILES)
            m = homogenize_metrics(nested_lookup('metric',environments[environment]))
            s = homogenize_services(nested_lookup('service',environments[environment]))
            k = homogenize_keyRequests(nested_lookup('keyRequests',environments[environment]))
            jinja_template = jinja_environment.get_template(t)
            file.write(jinja_template.render(module=module_name,
                                             slo_name=slo_name,
                                             metric=m[0],metricA=m[0],metricB=m[1],metricC=m[2],metricD=m[3],
                                             description=description,

                                             services=s[0],servicesA=s[0],servicesB=s[1],
                                             keyRequests=k[0],keyRequestsA=k[0],keyRequestsB=k[1],

                                             target=slo_definition_tresholds_failure,
                                             warning=slo_definition_tresholds_warning))
    
if __name__ == "__main__":

    # pre-initialization get current working directory
    cwd = os.getcwd()

    print(sys.argv)
    if len(sys.argv) != 2:
        print(".\convert.py <FOLDER>")
        print("Example: .\convert.py DE-3")
        print("Example: .\convert.py DE-3,DE-4,...")
        sys.exit()

    # init folder
    for folderName,businessLine in FOLDERS.items():
        businessLinePath = os.path.join(cwd,os.path.basename(businessLine))
        if not os.path.exists(businessLinePath):
            os.makedirs(businessLinePath)

    # for each folder
    for arg in [sys.argv[1]]:
        # return path of slo config files
        configFiles = glob.glob(pathname=os.path.join(cwd,os.path.basename(arg))+'\\*.yaml',
                               # root_dir=os.path.join(cwd,os.path.basename(arg)),
                                recursive=True) 

        # for each slo config file in folder
        for configFile in configFiles:
            main(configFile)