# Copyright 2020 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import dataclasses
import enum
import os.path
from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple
import xml.etree.ElementTree

# Short aliases for typing
Element = xml.etree.ElementTree.Element


@dataclasses.dataclass(frozen=True)
class Description:
    """Holds the data from a Wayland protocol <description> subtree."""

    # The value of the name summary of the <description>.
    summary: str

    # The text content of the <description>.
    description: str

    @staticmethod
    def parse_xml(e: Element) -> Optional['Description']:
        return Description(summary=e.get('summary'),
                           description=e.text.strip()
                           if e.text else '') if e is not None else None


class MessageArgType(enum.Enum):
    """The valid types of an <arg>."""
    INT = 'int'
    UINT = 'uint'
    FIXED = 'fixed'
    STRING = 'string'
    FD = 'fd'  # File descriptor
    ARRAY = 'array'  # untyped Array
    NEW_ID = 'new_id'  # Special type for constructing
    OBJECT = 'object'  # An interface


@dataclasses.dataclass(frozen=True)
class MessageArg:
    """Holds the data from a Wayland protocol <arg> subtree."""

    # The containing Message, for context.
    message: 'Message' = dataclasses.field(repr=False, hash=False)

    # The value of the name attribute of the <arg>.
    name: str

    # The value of the type attribute of the <arg>.
    type: MessageArgType

    # The value of the optional summary attribute of the <arg>.
    summary: Optional[str]

    # The value of the optional interface attribute of the <arg>.
    interface: Optional[str]

    # The value of the optional nullable attribute of the <arg>.
    nullable: Optional[bool]

    # The value of the optional enum attribute of the <arg>.
    enum: Optional[str]

    # The optional <description> child element of the <arg>.
    description: Optional[Description]

    @staticmethod
    def parse_xml(message: 'Message', e: Element) -> 'MessageArg':
        return MessageArg(message=message,
                          name=e.get('name'),
                          type=e.get('type'),
                          summary=e.get('summary'),
                          interface=e.get('interface'),
                          nullable=e.get('allow-null') == 'true'
                          if e.get('allow-null') else None,
                          enum=e.get('enum'),
                          description=Description.parse_xml(
                              e.find('description')))


class RequestType(enum.Enum):
    """The valid types of a <request> message."""
    DESTRUCTOR = 'destructor'


@dataclasses.dataclass(frozen=True)
class Message:
    """Holds the data from a Wayland protocol <request> OR <event> subtree."""

    # The containing Interface, for context.
    interface: 'Interface' = dataclasses.field(repr=False, hash=False)

    # If true, this message is an <event> in the containing interface.
    # Otherwise it is a <request>.
    is_event: bool

    # The value of the name attribute of the <request> or <event>.
    name: str

    # The value of the optional type attribute of the <request> Always empty
    # for <events>.
    request_type: Optional[RequestType]

    # The value of the optional since attribute of the <request> or <event>.
    since: Optional[int]

    # The optional <description> child element of the <request> or <event>.
    description: Optional[Description]

    # The child <arg> elements of the <request> or <event>
    args: Tuple[MessageArg, ...] = dataclasses.field(init=False)

    @staticmethod
    def parse_xml(interface: 'Interface', is_event: bool,
                  e: Element) -> 'Message':
        message = Message(
            interface=interface,
            is_event=is_event,
            name=e.get('name'),
            request_type=e.get('type'),
            since=int(e.get('since')) if e.get('since') else None,
            description=Description.parse_xml(e.find('description')))

        # Note: This is needed to finish up since the instance is frozen.
        object.__setattr__(
            message, 'args',
            tuple(MessageArg.parse_xml(message, c) for c in e.findall('arg')))

        return message


@dataclasses.dataclass(frozen=True)
class EnumEntry:
    """Holds the data from a Wayland protocol <entry> subtree."""

    # The containing Enum, for context.
    enum: 'Enum' = dataclasses.field(repr=False, hash=False)

    # The value of the name attribute of the <entry>.
    name: str

    # The value of the value attribute of the <entry>.
    value: int

    # The value of the optional summary attribute of the <entry>.
    summary: Optional[str]

    # The value of the optional since attribute of the <entry>.
    since: Optional[int]

    # The optional <description> child element of the <request> or <event>.
    description: Optional[Description]

    @staticmethod
    def parse_xml(enum: 'Enum', e: Element) -> 'EnumEntry':
        return EnumEntry(
            enum=enum,
            name=e.get('name'),
            value=int(e.get('value'), 0),
            summary=e.get('summary'),
            since=int(e.get('since'), 0) if e.get('since') else None,
            description=Description.parse_xml(e.find('description')))


@dataclasses.dataclass(frozen=True)
class Enum:
    """Holds the data from a Wayland protocol <enum> subtree."""

    # The containing Interface, for context.
    interface: 'Interface' = dataclasses.field(repr=False, hash=False)

    # The value of the name attribute of the <enum>.
    name: str

    # The value of the optional since attribute of the <enum>.
    since: Optional[int]

    # The value of the optional bitfield attribute of the <enum>.
    bitfield: Optional[bool]

    # The optional <description> child element of the <request> or <event>.
    description: Optional[Description]

    # The child <entry> elements for the <enum>.
    entries: Tuple[EnumEntry, ...] = dataclasses.field(init=False)

    @staticmethod
    def parse_xml(interface: 'Interface', e: Element) -> 'Enum':
        enum = Enum(interface=interface,
                    name=e.get('name'),
                    since=int(e.get('since'), 0) if e.get('since') else None,
                    bitfield=e.get('bitfield') == 'true'
                    if e.get('bitfield') else None,
                    description=Description.parse_xml(e.find('description')))

        # Note: This is needed to finish up since the instance is frozen.
        object.__setattr__(
            enum, 'entries',
            tuple(EnumEntry.parse_xml(enum, c) for c in e.findall('entry')))

        return enum


@dataclasses.dataclass(frozen=True)
class Interface:
    """Holds the data from a Wayland protocol <interface> subtree."""

    # The containing Protocol, for context.
    protocol: 'Protocol' = dataclasses.field(repr=False, hash=False)

    # The value of the name attribute of the <interface>.
    name: str

    # The value of the version attribute of the <interface>.
    version: int

    # The optional <description> child element of the <interface>.
    description: Optional[Description]

    # The child <request> elements for the <interface>.
    requests: Tuple[Message, ...] = dataclasses.field(init=False)

    # The child <event> elements for the <interface>.
    events: Tuple[Message, ...] = dataclasses.field(init=False)

    # The child <enum> elements for the <interface>.
    enums: Tuple[Enum, ...] = dataclasses.field(init=False)

    @staticmethod
    def parse_xml(protocol: 'Protocol', e: Element) -> 'Interface':
        interface = Interface(protocol=protocol,
                              name=e.get('name'),
                              version=int(e.get('version'), 0),
                              description=Description.parse_xml(
                                  e.find('description')))

        # Note: This is needed to finish up since the instance is frozen.
        object.__setattr__(
            interface, 'requests',
            tuple(
                Message.parse_xml(interface, False, c)
                for c in e.findall('request')))
        object.__setattr__(
            interface, 'events',
            tuple(
                Message.parse_xml(interface, True, c)
                for c in e.findall('event')))
        object.__setattr__(
            interface, 'enums',
            tuple(Enum.parse_xml(interface, c) for c in e.findall('enum')))

        return interface


@dataclasses.dataclass(frozen=True)
class Copyright:
    """Holds the data from a Wayland protocol <copyright> subtree."""

    # The text content of the <copyright>.
    text: str

    @staticmethod
    def parse_xml(e: Element) -> Optional['Copyright']:
        return Copyright(text=e.text.strip()) if e is not None else None


@dataclasses.dataclass(frozen=True)
class Protocol:
    """Holds the data from a Wayland protocol <protocol> subtree."""

    # The universe of known protocols this is part of.
    protocols: 'Protocols' = dataclasses.field(repr=False, hash=False)

    # The containing base filename (no path, no extension), for context.
    filename: str

    # The value of the name attribute of the <protocol>.
    name: str

    # The optional <copyright> child element of the <protocol>.
    copyright: Optional[Copyright]

    # The optional <description> child element of the <protocol>.
    description: Optional[Description]

    # The child <interface> elements for the <protocol>.
    interfaces: Tuple[Interface, ...] = dataclasses.field(init=False)

    @staticmethod
    def parse_xml(protocols: 'Protocols', filename: str,
                  e: Element) -> 'Protocol':
        protocol = Protocol(protocols,
                            filename=filename,
                            name=e.get('name'),
                            copyright=Copyright.parse_xml(e.find('copyright')),
                            description=Description.parse_xml(
                                e.find('description')))

        # Note: This is needed to finish up since the instance is frozen.
        object.__setattr__(
            protocol, 'interfaces',
            tuple(
                Interface.parse_xml(protocol, i)
                for i in e.findall('interface')))

        return protocol


@dataclasses.dataclass(frozen=True)
class Protocols:
    """Holds the data from multiple Wayland protocol files."""

    # The parsed protocol dataclasses
    protocols: Tuple[Protocol, ...] = dataclasses.field(init=False)

    @staticmethod
    def parse_xml_files(filenames: Iterable[str]) -> 'Protocols':
        protocols = Protocols()

        # Note: This is needed to finish up since the instance is frozen.
        object.__setattr__(
            protocols, 'protocols',
            tuple(
                Protocol.parse_xml(
                    protocols,
                    os.path.splitext(os.path.basename(filename))[0],
                    xml.etree.ElementTree.parse(filename).getroot())
                for filename in filenames))

        return protocols