from typing import Optional, List

from olc.bean.constant import (
    DIMENSION_GROUP_SPLIT,
    SUBGROUP_SPLIT,
    DIMENSION_SPLIT,
    EQUAL,
)
from olc.bean.olc_control_request import OlcControlRequest


class OlcTag:
    def __init__(
        self,
        match: str = "",
        tag: str = "",
        value: str = "",
        share: bool = False,
    ):
        self.match = match
        self.tag = tag
        self.value = value
        self.share = share

    def __repr__(self):
        return f"OlcTag(match = {self.match}, tag = {self.tag}, value = {self.value}, share = {self.share})"

    def __str__(self):
        return self.__repr__()


class TagGroup:
    def __init__(
        self,
        domain: str = "",
        name: str = "",
        priority: int = 0,
        enabled: bool = True,
        tags: Optional[List[OlcTag]] = None,
    ):
        self.domain = domain
        self.name = name
        self.priority = priority
        self.enabled = enabled
        self.tags = tags if tags is not None else []

    def __repr__(self):
        return (
            f"TagGroup(domain = {self.domain}, name = {self.name}, "
            f"priority = {self.priority}, enabled = {self.enabled}, "
            f"tags = {self.tags})"
        )

    def __str__(self):
        return self.__repr__()

    def __hash__(self):
        return hash((self.domain, self.name))

    def __eq__(self, other):
        if not isinstance(other, TagGroup):
            return False
        return self.domain == other.domain and self.name == other.name

    def create_sub_group(self) -> bool:
        if self.tags is not None and len(self.tags) != 0:
            for tag in self.tags:
                """
                share = True 不创建
                """
                is_create = not tag.share
                if is_create:
                    # 创建子组
                    return True
        return False


class SubGroup(TagGroup):

    def __init__(self, tag_group: TagGroup, request: OlcControlRequest):
        super().__init__(
            domain=tag_group.domain,
            name=tag_group.name,
            priority=tag_group.priority,
            enabled=tag_group.enabled,
            tags=tag_group.tags,
        )
        self.parent = tag_group
        self.reset_tags(request)
        self.reset_name()

    def reset_tags(self, request: OlcControlRequest):
        tags = []
        for olc_tag in self.tags:
            if not olc_tag.share:
                dimension_tag = olc_tag.tag
                value = request.tags.get(dimension_tag, "")
                tags.append(
                    OlcTag(match=EQUAL, tag=dimension_tag, value=value, share=True)
                )
            self.tags = tags

    def reset_name(self):
        name_build = [self.name, SUBGROUP_SPLIT]
        sorted(self.tags, key=lambda x: x.tag)
        for olc_tag in self.tags:
            name_build.append(olc_tag.tag)
            name_build.append(DIMENSION_SPLIT)
            name_build.append(olc_tag.value)
            name_build.append(DIMENSION_GROUP_SPLIT)
        # 移除最后一个 DIMENSION_GROUP_SPLIT
        reset_name = "".join(name_build[:-1])
        self.name: str = reset_name