#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2022 F4PGA Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0

from pathlib import Path
from copy import copy
from os import listdir as os_listdir
from json import dump as json_dump, load as json_load

from f4pga.flows.common import ResolutionEnv, deep
from f4pga.flows.stage import Stage


def open_flow_cfg(path: str) -> dict:
    with Path(path).open("r") as rfptr:
        return json_load(rfptr)


def p_get_ovs_raw(dict_name: str, flow_cfg, part: "str | None", stage: "str | None"):
    vals = flow_cfg.get(dict_name)
    if vals is None:
        vals = {}
    if part is not None:
        platform_vals = flow_cfg[part].get(dict_name)
        if platform_vals is not None:
            vals.update(platform_vals)
        if stage is not None:
            stage_deps = flow_cfg[part][stage].get(dict_name)
            if stage_deps is not None:
                vals.update(stage_deps)

    return vals


def verify_platform_name(platform: str, mypath: str):
    for plat_def_filename in os_listdir(str(Path(mypath) / "platforms")):
        platform_name = str(Path(plat_def_filename).stem)
        if platform == platform_name:
            return True
    return False


class FlowDefinition:
    stages: "dict[str, Stage]"  # stage name -> module path mapping
    r_env: ResolutionEnv

    def __init__(self, flow_def: dict, r_env: ResolutionEnv):
        self.flow_def = flow_def
        self.r_env = r_env
        self.stages = {}

        global_vals = flow_def.get("values")
        if global_vals is not None:
            self.r_env.add_values(global_vals)

        for stage_name, stage_def in flow_def["stages"].items():
            self.stages[stage_name] = Stage(stage_name, stage_def)

    def stage_names(self):
        return self.stages.keys()


KWORDS = {"dependencies", "values", "default_platform", "default_target"}


class ProjectFlowConfig:
    flow_cfg: dict
    path: str

    def __init__(self, path: str):
        self.flow_cfg = {}
        self.path = copy(path)

    def parts(self):
        for part in self.flow_cfg.keys():
            if part not in KWORDS:
                yield part

    def get_default_part(self) -> "str | None":
        return self.flow_cfg.get("default_part")

    def get_default_target(self, part: str) -> "str | None":
        return self.flow_cfg[part].get("default_target")

    def get_dependencies_raw(self, part: "str | None" = None):
        """
        Get dependencies without value resolution applied.
        """
        return p_get_ovs_raw("dependencies", self.flow_cfg, part, None)

    def get_values_raw(self, part: "str | None" = None, stage: "str | None" = None):
        """
        Get values without value resolution applied.
        """
        return p_get_ovs_raw("values", self.flow_cfg, part, stage)

    def get_stage_value_overrides(self, part: str, stage: str):
        stage_vals_ovds = {}

        vals = self.flow_cfg.get("values")
        if vals is not None:
            stage_vals_ovds.update(vals)
        stage_cfg = self.flow_cfg[part].get(stage)
        if stage_cfg is not None:
            vals = stage_cfg.get("values")
            if vals is not None:
                stage_vals_ovds.update(vals)

        return stage_vals_ovds

    def get_dependency_platform_overrides(self, part: str):
        platform_ovds = self.flow_cfg[part].get("dependencies")
        if platform_ovds is None:
            return {}
        return platform_ovds


def override_prj_flow_cfg_by_cli(cfg: ProjectFlowConfig, cli_d: "dict[str, dict[str, dict]]"):
    for part_name, part_cfg in cli_d.items():
        print(f"OVERRIDING CONFIG FOR {part_name}")
        p_cfg = cfg.flow_cfg.get(part_name)
        if p_cfg is None:
            p_cfg = {}
            cfg.flow_cfg[part_name] = p_cfg
        cli_p_values = part_cfg.get("values")
        cli_p_dependencies = part_cfg.get("dependencies")
        p_values = p_cfg.get("values")
        p_dependencies = p_cfg.get("dependencies")
        if cli_p_values is not None:
            if p_values is None:
                p_values = {}
                part_cfg["values"] = p_values
            p_values.update(cli_p_values)
        if cli_p_dependencies is not None:
            if p_dependencies is None:
                p_dependencies = {}
                part_cfg["dependencies"] = p_dependencies
            p_dependencies.update(cli_p_dependencies)

        for stage_name, cli_stage_cfg in part_cfg.items():
            if stage_name in KWORDS:
                continue

            stage_cfg = part_cfg.get(stage_name)
            if stage_cfg is None:
                stage_cfg = {}
                part_cfg[stage_name] = stage_cfg

            stage_values = stage_cfg.get("values")
            stage_dependencies = stage_cfg.get("dependencies")
            cli_stage_values = cli_stage_cfg.get("values")
            cli_stage_dependencies = cli_stage_cfg.get("dependencies")

            if cli_stage_values is not None:
                if stage_values is None:
                    stage_values = {}
                    stage_cfg["values"] = stage_values
                stage_values.update(cli_stage_values)
            if cli_stage_dependencies is not None:
                if stage_dependencies is None:
                    stage_dependencies = {}
                    stage_cfg["dependencies"] = stage_dependencies
                stage_dependencies.update(cli_stage_dependencies)


class FlowConfig:
    part: str
    r_env: ResolutionEnv
    dependencies_explicit: "dict[str, ]"
    stages: "dict[str, Stage]"

    def __init__(self, project_config: ProjectFlowConfig, platform_def: FlowDefinition, part: str):
        self.r_env = platform_def.r_env
        self.r_env.add_values(project_config.get_values_raw(part))
        self.stages = platform_def.stages
        self.part = part

        self.dependencies_explicit = deep(lambda p: str(Path(p).resolve()), allow_none=True)(
            self.r_env.resolve(project_config.get_dependencies_raw(part))
        )

        for stage_name, stage in platform_def.stages.items():
            project_val_ovds = project_config.get_stage_value_overrides(part, stage_name)
            stage.value_overrides.update(project_val_ovds)

    def get_dependency_overrides(self):
        return self.dependencies_explicit

    def get_r_env(self, stage_name: str) -> ResolutionEnv:
        stage = self.stages[stage_name]
        r_env = copy(self.r_env)
        r_env.add_values(stage.value_overrides)

        return r_env

    def get_stage(self, stage_name: str) -> Stage:
        return self.stages[stage_name]


class FlowConfigException(Exception):
    path: str
    message: str

    def __init__(self, path: str, message: str):
        self.path = path
        self.message = message

    def __str__(self) -> str:
        return f"Error in config `{self.path}: {self.message}"


def open_project_flow_cfg(path: str) -> ProjectFlowConfig:
    cfg = ProjectFlowConfig(path)
    with Path(path).open("r") as rfptr:
        cfg.flow_cfg = json_load(rfptr)
    return cfg