def read_file() -> str:
    """Read a file and return the text.
    
    This method will be attached to our parser as a helper below."""
    with open("data/star_wars/universe.yml") as f:
        config = f.read()
    return config

print(read_file())

from typing import Any, Dict, Iterator, Optional, Tuple, cast
import json

from ruamel.yaml import YAML

from ntc_rosetta.helpers import json_helpers as jh

from yangify import parser
from yangify.parser.text_tree import parse_indented_config
from yangify.parser import Parser, ParserData


def to_yaml(config: str) -> Dict[str,Any]:
    yaml = YAML()
    config_data = yaml.load(config)
    return config_data


class IndividualData(Parser):
    class Yangify(ParserData):
        path = "/napalm-star-wars:individual"

        def extract_elements(self) -> Iterator[Tuple[str, Dict[str, Any]]]:
            for person in jh.query("individuals", self.native, default=[]):
                yield "individual", cast(Dict[str, Any], person)

    def name(self) -> Optional[str]:
        return jh.query("name", self.yy.native)

    def age(self) -> int:
        return jh.query("age", self.yy.native)

    def affiliation(self) -> bool:
        return jh.query("affiliation", self.yy.native)


class Universe(Parser):
    class Yangify(ParserData):
        path = "/napalm-star-wars:universe"

    individual = IndividualData


class DummyParser(parser.RootParser):
    """
    DummyParser expects as native data a dictionary where the `universe`
    key is reserved for the device configuration.
    """

    class Yangify(parser.ParserData):
        def init(self) -> None:
            self.root_native = to_yaml(self.root_native)
            self.native = self.root_native["universe"]

    universe = Universe

from ntc_rosetta.drivers.base import Driver
from yangson.datamodel import DataModel
import pathlib

# This part looks just like the ios and junos drivers in ntc-rosetta
class DummyDriverNapalmStarWars(Driver):
    parser = DummyParser
    translator = None
    datamodel_name = "napalm_star_wars"
    
    # These are the overloads.  Please see the file structure and notes
    # in the introduction
    @classmethod
    def get_data_model(cls) -> DataModel:
        base = pathlib.Path("/ntc_dummies/data/yang")
        lib = base.joinpath("dummies/models/napalm-star-wars-library.json")
        path = [
            base.joinpath("dummies/models/napalm-star-wars"),
        ]
        return DataModel.from_file(lib, path)
    
    @classmethod
    def get_datamodel(cls) -> DataModel:
        if cls._datamodel is None:
            cls._datamodel = cls.get_data_model()
        return cls._datamodel

# If everything worked
dummy_driver = DummyDriverNapalmStarWars()
# Let's see if we properly loaded the DataModel from the new YANG file
print(dummy_driver.get_datamodel().ascii_tree())

config_data = read_file()

# Alternate options
# my_universe = DummyParser(dummy_driver.get_datamodel(), native=config_data)
# print(my_universe.process().raw_value())

parsed = dummy_driver.parse(native=config_data)
print(json.dumps(parsed.raw_value(), indent=4))

from yangify import translator
from yangify.translator import Translator, TranslatorData
from yangify.translator.config_tree import ConfigTree


class Individual(Translator):
    """
    Implements /napalm-star-wars:universe
    """
    class Yangify(translator.TranslatorData):
        def pre_process(self) -> None:
            self.result = self.result.new_section("")

    def name(self, value: Optional[str]) -> None:
        self.yy.result.add_command(f"  - {value}")

    def age(self, value: Optional[int]) -> None:
        self.yy.result.add_command(f"    {value}")

    def affiliation(self, value: Optional[str]) -> None:
        self.yy.result.add_command(f"    {value[0]}")

class Universe(Translator):
    class Yangify(translator.TranslatorData):
        def pre_process(self) -> None:
            self.result.new_section("individuals:")
    individual = Individual
    
class DummyTranslator(translator.RootTranslator):
    class Yangify(translator.TranslatorData):
        def init(self) -> None:
            self.root_result = ConfigTree()
            self.result = self.root_result
            self.result.add_command("---")
            self.result.add_command("universe:")

        def post(self) -> None:
            self.root_result = self.root_result.to_string()

    universe = Universe

# update the driver
DummyDriverNapalmStarWars.translator = DummyTranslator
dummy_driver = DummyDriverNapalmStarWars()

# Alternate options
# my_universe = DummyTranslator(dummy_driver.get_datamodel(), candidate=parsed.raw_value())
# print(my_universe.process())

translated = dummy_driver.translate(candidate=parsed.raw_value())
print(translated)

irt = parsed.datamodel.parse_resource_id("/napalm-star-wars:universe/individual=Yoda")
current_data = parsed.root.goto(irt)
print("Current Yoda: ", json.dumps(current_data.raw_value(), indent=2))
modify_data = current_data.raw_value()
modify_data['affiliation'] = 'napalm-star-wars:MERCENARY'

stub = current_data.update(modify_data, raw=True)
print("Candidate Yoda: ", json.dumps(stub.raw_value(), indent=2))
stub.validate()

modify_data['affiliation'] = 'napalm-star-wars:EMPIRE'

stub = current_data.update(modify_data, raw=True)
print("Candidate Yoda: ", json.dumps(stub.raw_value(), indent=2))
stub.validate()
print("Validated!")

translated = dummy_driver.translate(candidate=stub.top().raw_value())
print(translated)