# Copyright (c) 2011-2022, Manfred Moitzi
# License: MIT License
from __future__ import annotations
from typing import (
    Any,
    Iterable,
    Iterator,
    KeysView,
    Optional,
    Sequence,
    TYPE_CHECKING,
    Union,
)
import logging
from collections import OrderedDict

from ezdxf.lldxf import const
from ezdxf.lldxf.tags import group_tags, Tags, DXFTag
from ezdxf.lldxf.types import strtag
from ezdxf.lldxf.validator import header_validator
from ezdxf.sections.headervars import (
    HEADER_VAR_MAP,
    version_specific_group_code,
)

if TYPE_CHECKING:
    from ezdxf.lldxf.tagwriter import AbstractTagWriter

logger = logging.getLogger("ezdxf")

MIN_HEADER_TEXT = """  0
SECTION
  2
HEADER
  9
$ACADVER
  1
AC1009
  9
$DWGCODEPAGE
  3
ANSI_1252
  9
$HANDSEED
  5
FF
"""

# Additional variables may be stored as DICTIONARYVAR in the OBJECTS
# section in the DICTIONARY "AcDbVariableDictionary" of the root dict.
# - CANNOSCALE
# - CENTEREXE
# - CENTERLTYPEFILE
# - CETRANSPARENCY
# - CMLEADERSTYLE
# - CTABLESTYLE
# - CVIEWDETAILSTYLE
# - CVIEWSECTIONSTYLE
# - LAYEREVAL
# - LAYERNOTIFY
# - LIGHTINGUNITS
# - MSLTSCALE


class CustomVars:
    """The :class:`CustomVars` class stores custom properties in the DXF header as
    $CUSTOMPROPERTYTAG and $CUSTOMPROPERTY values. Custom properties require DXF R2004
    or later, `ezdxf` can create custom properties for older DXF versions as well, but
    AutoCAD will not show that properties.

    """

    def __init__(self) -> None:
        self.properties: list[tuple[str, str]] = list()

    def __len__(self) -> int:
        """Count of custom properties."""
        return len(self.properties)

    def __iter__(self) -> Iterator[tuple[str, str]]:
        """Iterate over all custom properties as ``(tag, value)`` tuples."""
        return iter(self.properties)

    def clear(self) -> None:
        """Remove all custom properties."""
        self.properties.clear()

    def append(self, tag: str, value: str) -> None:
        """Add custom property as ``(tag, value)`` tuple."""
        # custom properties always stored as strings
        self.properties.append((tag, str(value)))

    def get(self, tag: str, default: Optional[str] = None):
        """Returns the value of the first custom property `tag`."""
        for key, value in self.properties:
            if key == tag:
                return value
        else:
            return default

    def has_tag(self, tag: str) -> bool:
        """Returns ``True`` if custom property `tag` exist."""
        return self.get(tag) is not None

    def remove(self, tag: str, all: bool = False) -> None:
        """Removes the first occurrence of custom property `tag`, removes all
        occurrences if `all` is ``True``.

        Raises `:class:`DXFValueError` if `tag`  does not exist.

        """
        found_tag = False
        for item in self.properties:
            if item[0] == tag:
                self.properties.remove(item)
                found_tag = True
                if not all:
                    return
        if not found_tag:
            raise const.DXFValueError(f"Tag '{tag}' does not exist")

    def replace(self, tag: str, value: str) -> None:
        """Replaces the value of the first custom property `tag` by a new
        `value`.

        Raises :class:`DXFValueError` if `tag`  does not exist.

        """
        properties = self.properties
        for index in range(len(properties)):
            name = properties[index][0]
            if name == tag:
                properties[index] = (name, value)
                return

        raise const.DXFValueError(f"Tag '{tag}' does not exist")

    def write(self, tagwriter: AbstractTagWriter) -> None:
        """Export custom properties as DXF tags. (internal API)"""
        for tag, value in self.properties:
            s = f"  9\n$CUSTOMPROPERTYTAG\n  1\n{tag}\n  9\n$CUSTOMPROPERTY\n  1\n{value}\n"
            tagwriter.write_str(s)


def default_vars() -> OrderedDict:
    vars = OrderedDict()
    for vardef in HEADER_VAR_MAP.values():
        vars[vardef.name] = HeaderVar(DXFTag(vardef.code, vardef.default))
    return vars


class HeaderSection:
    MIN_HEADER_TAGS = Tags.from_text(MIN_HEADER_TEXT)
    name = "HEADER"

    def __init__(self) -> None:
        self.hdrvars: dict[str, HeaderVar] = OrderedDict()
        self.custom_vars = CustomVars()

    @classmethod
    def load(cls, tags: Optional[Iterable[DXFTag]] = None) -> HeaderSection:
        """Constructor to generate header variables loaded from DXF files
        (untrusted environment).

        Args:
            tags: DXF tags as Tags() or ExtendedTags()

        (internal API)
        """
        if tags is None:  # create default header
            # files without a header have the default version: R12
            return cls.new(dxfversion=const.DXF12)
        section = cls()
        section.load_tags(iter(tags))
        return section

    @classmethod
    def new(cls, dxfversion=const.LATEST_DXF_VERSION) -> HeaderSection:
        section = HeaderSection()
        section.hdrvars = default_vars()
        section["$ACADVER"] = dxfversion
        return section

    def load_tags(self, tags: Iterable[DXFTag]) -> None:
        """Constructor to generate header variables loaded from DXF files
        (untrusted environment).

        Args:
            tags: DXF tags as Tags() or ExtendedTags()

        """
        _tags = iter(tags) or iter(self.MIN_HEADER_TAGS)
        section_tag = next(_tags)
        name_tag = next(_tags)

        if section_tag != (0, "SECTION") or name_tag != (2, "HEADER"):
            raise const.DXFStructureError("Critical structure error in HEADER section.")

        groups = group_tags(header_validator(_tags), splitcode=9)
        custom_property_stack = []  # collect $CUSTOMPROPERTY/TAG
        for group in groups:
            name = group[0].value
            value = group[1]
            if name in ("$CUSTOMPROPERTYTAG", "$CUSTOMPROPERTY"):
                custom_property_stack.append(value.value)
            else:
                self.hdrvars[name] = HeaderVar(value)

        custom_property_stack.reverse()
        while len(custom_property_stack):
            try:
                self.custom_vars.append(
                    tag=custom_property_stack.pop(),
                    value=custom_property_stack.pop(),
                )
            except IndexError:  # internal exception
                break

    @classmethod
    def from_text(cls, text: str) -> HeaderSection:
        """Load constructor from text for testing"""
        return cls.load(Tags.from_text(text))

    def _headervar_factory(self, key: str, value: Any) -> DXFTag:
        if key in HEADER_VAR_MAP:
            factory = HEADER_VAR_MAP[key].factory
            return factory(value)
        else:
            raise const.DXFKeyError(f"Invalid header variable {key}.")

    def __len__(self) -> int:
        """Returns count of header variables."""
        return len(self.hdrvars)

    def __contains__(self, key) -> bool:
        """Returns ``True`` if header variable `key` exist."""
        return key in self.hdrvars

    def varnames(self) -> KeysView:
        """Returns an iterable of all header variable names."""
        return self.hdrvars.keys()

    def export_dxf(self, tagwriter: AbstractTagWriter) -> None:
        """Exports header section as DXF tags. (internal API)"""

        def _write(name: str, value: Any) -> None:
            if value.value is None:
                logger.info(f"did not write header var {name}, value is None.")
                return
            tagwriter.write_tag2(9, name)
            group_code = version_specific_group_code(name, dxfversion)
            # fix invalid group codes
            if group_code != value.code:
                value = HeaderVar((group_code, value.value))
            tagwriter.write_str(str(value))

        dxfversion: str = tagwriter.dxfversion
        write_handles = tagwriter.write_handles

        tagwriter.write_str("  0\nSECTION\n  2\nHEADER\n")
        save = self["$ACADVER"]
        self["$ACADVER"] = dxfversion
        for name, value in header_vars_by_priority(self.hdrvars, dxfversion):
            if not write_handles and name == "$HANDSEED":
                continue  # skip $HANDSEED
            _write(name, value)
            if name == "$LASTSAVEDBY":  # ugly hack, but necessary for AutoCAD
                self.custom_vars.write(tagwriter)
        self["$ACADVER"] = save
        tagwriter.write_str("  0\nENDSEC\n")

    def get(self, key: str, default: Any = None) -> Any:
        """Returns value of header variable `key` if exist, else the `default`
        value.

        """
        if key in self.hdrvars:
            return self.__getitem__(key)
        else:
            return default

    def __getitem__(self, key: str) -> Any:
        """Get header variable `key` by index operator like:
        :code:`drawing.header['$ACADVER']`

        """
        try:
            return self.hdrvars[key].value
        except KeyError:  # map exception
            raise const.DXFKeyError(str(key))

    def __setitem__(self, key: str, value: Any) -> None:
        """Set header variable `key` to `value` by index operator like:
        :code:`drawing.header['$ANGDIR'] = 1`

        """
        try:
            tags = self._headervar_factory(key, value)
        except (IndexError, ValueError):
            raise const.DXFValueError(str(value))
        self.hdrvars[key] = HeaderVar(tags)

    def __delitem__(self, key: str) -> None:
        """Delete header variable `key` by index operator like:
        :code:`del drawing.header['$ANGDIR']`

        """
        try:
            del self.hdrvars[key]
        except KeyError:  # map exception
            raise const.DXFKeyError(str(key))

    def reset_wcs(self):
        """Reset the current UCS settings to the :ref:`WCS`."""
        self["$UCSBASE"] = ""
        self["$UCSNAME"] = ""
        self["$UCSORG"] = (0, 0, 0)
        self["$UCSXDIR"] = (1, 0, 0)
        self["$UCSYDIR"] = (0, 1, 0)
        self["$UCSORTHOREF"] = ""
        self["$UCSORTHOVIEW"] = 0
        self["$UCSORGTOP"] = (0, 0, 0)
        self["$UCSORGBOTTOM"] = (0, 0, 0)
        self["$UCSORGLEFT"] = (0, 0, 0)
        self["$UCSORGRIGHT"] = (0, 0, 0)
        self["$UCSORGFRONT"] = (0, 0, 0)
        self["$UCSORGBACK"] = (0, 0, 0)


def header_vars_by_priority(
    header_vars: dict[str, HeaderVar], dxfversion: str
) -> Iterable[tuple]:
    order = []
    for name, value in header_vars.items():
        vardef = HEADER_VAR_MAP.get(name, None)
        if vardef is None:
            logger.info(f"Header variable {name} ignored, dxfversion={dxfversion}.")
            continue
        if vardef.mindxf <= dxfversion <= vardef.maxdxf:
            order.append((vardef.priority, (name, value)))
    order.sort()
    for priority, tag in order:
        yield tag


class HeaderVar:
    def __init__(self, tag: Union[DXFTag, Sequence]):
        self.tag = tag

    @property
    def code(self) -> int:
        return self.tag[0]

    @property
    def value(self) -> Any:
        return self.tag[1]

    @property
    def ispoint(self) -> bool:
        return self.code == 10

    def __str__(self) -> str:
        if self.ispoint:
            code, value = self.tag
            s = []
            for coord in value:
                s.append(strtag((code, coord)))
                code += 10
            return "".join(s)
        else:
            return strtag(self.tag)  # type: ignore