"""Provides a consistent way to access the provided Dinwoodie and IEA Task 26 data
libraries.

All library data should adhere to the followind directory structure where <library>
signifies the user's input library path:
```
<library>
  ├── project
    ├── config     <- Project-level configuration files
    ├── port       <- Port configuration files
    ├── plant      <- Wind farm layout files
  ├── cables       <- Export and Array cable configuration files
  ├── substations  <- Substation configuration files
  ├── turbines     <- Turbine configuration and power curve files
  ├── vessels      <- Land-based and offshore servicing equipment configuration files
  ├── weather      <- Weather profiles
  ├── results      <- The analysis log files and any saved output data
```
"""

from __future__ import annotations

import re
from copy import deepcopy
from typing import Any
from pathlib import Path

import yaml


ROOT = Path(__file__).parents[2].resolve()
DEFAULT_LIBRARY = ROOT / "library"
CODE_COMPARISON = DEFAULT_LIBRARY / "code_comparison"
BASE_CASES = DEFAULT_LIBRARY / "baseline"

DINWOODIE = CODE_COMPARISON / "dinwoodie"
IEA_26 = CODE_COMPARISON / "iea26"
COREWIND = DEFAULT_LIBRARY / "corewind"

OSW_FIXED = BASE_CASES / "offshore_fixed"
LBW = BASE_CASES / "land_based"

library_map = {
    "DINWOODIE": DINWOODIE,
    "IEA_26": IEA_26,
    "IEA26": IEA_26,
    "COREWIND": COREWIND,
    "OSW_FIXED": OSW_FIXED,
    "LBW": LBW,
    "LAND_BASED": LBW,
}

# YAML loader that is able to read scientific notation
custom_loader = yaml.SafeLoader
custom_loader.add_implicit_resolver(
    "tag:yaml.org,2002:float",
    re.compile(
        """^(?:
     [-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+]?[0-9]+)?
    |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
    |\\.[0-9_]+(?:[eE][-+][0-9]+)?
    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*
    |[-+]?\\.(?:inf|Inf|INF)
    |\\.(?:nan|NaN|NAN))$""",
        re.X,
    ),
    list("-+0123456789."),
)



[docs]
def load_yaml(path: str | Path, fname: str | Path) -> Any:
    """Loads and returns the contents of the YAML file.

    Parameters
    ----------
    path : str | Path
        Path to the file to be loaded.
    fname : str | Path
        Name of the file (ending in .yaml or .yml) to be loaded.

    Returns
    -------
    Any
        Whatever content is in the YAML file.
    """
    if isinstance(path, str):
        path = Path(path).resolve()
    with (path / fname).open() as f:
        return yaml.load(f, Loader=custom_loader)




[docs]
def create_library_structure(
    library_path: str | Path, create_init: bool = False
) -> None:
    """Creates the following library structure at ``library_path``. If ``library_path``
    does not exist, then the method will fail.

    .. code-block:: text

        <library_path>/
        └── project
            └── config     <- Project-level configuration files
            └── port       <- Port configuration files
            └── plant      <- Wind farm layout files
        └── cables       <- Export and Array cable configuration files
        └── substations  <- Substation configuration files
        └── turbines     <- Turbine configuration and power curve files
        └── vessels      <- Land-based and offshore servicing equipment configuration files
        └── weather      <- Weather profiles
        └── results      <- The analysis log files and any saved output data

    Parameters
    ----------
    library_path : str | Path
        The folder under which the subfolder structure should be created.
    create_init : bool
        If True, create "__init__.py" in each of the folders so that python installation
        processes will register the files, and if False, only create the folders, by
        default False.

    Raises
    ------
    FileNotFoundError
        Raised if ``library_path`` is not a directory
    """  # noqa: E501
    if isinstance(library_path, str):
        library_path = Path(library_path)
    library_path = library_path.resolve(strict=True)
    if create_init:
        (library_path / "__init__.py").touch()

    folders = (
        "project/config",
        "project/port",
        "project/plant",
        "cables",
        "substations",
        "turbines",
        "vessels",
        "weather",
        "results",
    )
    # Make the project/ subfolder structure once and make the rest without parents
    (library_path / folders[0]).mkdir(parents=True, exist_ok=True)
    for folder in folders:
        f = library_path / folder
        f.mkdir(exist_ok=True)
        if create_init:
            f = f / "__init__.py"
            f.touch()




[docs]
def convert_failure_data(
    configuration: str | Path | dict,
    which: str,
    save_name: str | Path | None = None,
    return_dict: bool = False,
) -> None | dict:
    """Converts the pre-v0.10 failure configuration data for cable, turbine, substation
    data in both individual files or consolidated configurations to be in the v0.10+
    style.

    Parameters
    ----------
    configuration : str | Path | dict
        The configuration file or dictionary containing failure data.
    which : str
        The type of configuration. Muat be one of "cable", "substation", "turbine",
        or "configuration" where "configuration" is a consolidated simulation
        configuration file containing any or all of the different types.
    save_name : str | Path | None, optional
        The file path and name of where to save the converted configuration, by default
        None.
    return_dict : bool, optional
        Use True to return the converted dictionary, by default False.

    Returns
    -------
    None | dict
        If :py:attr:`return_dict` is True, then `dict`, otherwise None.

    Raises
    ------
    FileNotFoundError
        Raised if the :py:attr:`configuration` can't be found.
    ValueError
        Raised if :py:attr:`configuration` can't be converted to a dictionary because
        a dictionary was not passed nor was a valid file path to load.
    ValueError
        Raised if :py:attr:`which` received an invalid input.
    """
    configuration = deepcopy(configuration)
    original = deepcopy(configuration)
    if isinstance(configuration, str):
        configuration = Path(configuration)
    if isinstance(configuration, Path):
        configuration = configuration.resolve()
        if not configuration.is_file():
            msg = f"{configuration} cannot be found, please check the path."
            raise FileNotFoundError(msg)
        configuration = load_yaml(configuration.parent, configuration.name)

    if not isinstance(configuration, dict):
        if isinstance(original, (str, Path)):
            msg = f"{original} could not be converted to a dictionary."
        else:
            msg = "Input to `configuration` was not a dictionary."
        raise TypeError(msg)

    opts = ("cable", "turbine", "substation", "configuration")
    match which:
        case "cable":
            configuration["failures"] = list(configuration["failures"].values())
        case "turbine" | "substation":
            for key, val in configuration.items():
                if not isinstance(val, dict) or key == "power_curve":
                    continue
                configuration[key]["failures"] = list(
                    configuration[key]["failures"].values()
                )
        case "configuration":
            if "cables" in configuration:
                for name, config in configuration["cables"].items():
                    configuration["cables"][name]["failures"] = list(
                        config["failures"].values()
                    )
            if "turbines" in configuration:
                for name, config in configuration["turbines"].items():
                    for key, val in config.items():
                        if isinstance(val, dict) and key != "power_curve":
                            configuration["turbines"][name][key]["failures"] = list(
                                val["failures"].values()
                            )
            if "substations" in configuration:
                for name, config in configuration["substations"].items():
                    for key, val in config.items():
                        if isinstance(val, dict):
                            configuration["substations"][name][key]["failures"] = list(
                                val["failures"].values()
                            )
        case _:
            raise ValueError(f"`which` must be one of: {', '.join(opts)}")

    if save_name is not None:
        with Path(save_name).open("w") as f:
            yaml.dump(configuration, f, default_flow_style=False, sort_keys=False)

    if return_dict:
        return configuration
    return None