# -*- coding: utf-8 -*-
__author__ = "Anand Kalaiarasi Ganeson, ganan642@student.liu.se, 2012-03-19, and Martin Sjölund"
__license__ = """
 This file is part of OpenModelica.

 Copyright (c) 1998-CurrentYear, Open Source Modelica Consortium (OSMC),
 c/o Linköpings universitet, Department of Computer and Information Science,
 SE-58183 Linköping, Sweden.

 All rights reserved.

 THIS PROGRAM IS PROVIDED UNDER THE TERMS OF THE BSD NEW LICENSE OR THE
 GPL VERSION 3 LICENSE OR THE OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.2.
 ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
 RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3,
 ACCORDING TO RECIPIENTS CHOICE.

 The OpenModelica software and the OSMC (Open Source Modelica Consortium)
 Public License (OSMC-PL) are obtained from OSMC, either from the above
 address, from the URLs: http://www.openmodelica.org or
 http://www.ida.liu.se/projects/OpenModelica, and in the OpenModelica
 distribution. GNU version 3 is obtained from:
 http://www.gnu.org/copyleft/gpl.html. The New BSD License is obtained from:
 http://www.opensource.org/licenses/BSD-3-Clause.

 This program is distributed WITHOUT ANY WARRANTY; without even the implied
 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, EXCEPT AS
 EXPRESSLY SET FORTH IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE
 CONDITIONS OF OSMC-PL.
"""
__status__ = "Prototype"
__maintainer__ = "https://openmodelica.org"

from typing import Any

from pyparsing import (
    alphanums,
    alphas,
    Combine,
    DelimitedList,
    Dict,
    infix_notation,
    Forward,
    Group,
    Keyword,
    nums,
    opAssoc,
    Optional,
    QuotedString,
    replace_with,
    StringEnd,
    Suppress,
    Word,
)


def convert_numbers(s, loc, toks):
    """Convert parsed numeric tokens to int (falls back to float)."""
    n = toks[0]
    try:
        return int(n)
    except ValueError:
        return float(n)


def convert_string2(s, s2):
    """Convert a quoted-string token back to a Modelica string literal."""
    tmp = s2[0].replace("\\\"", "\"")
    tmp = tmp.replace("\"", "\\\"")
    tmp = tmp.replace("\'", "\\'")
    tmp = tmp.replace("\f", "\\f")
    tmp = tmp.replace("\n", "\\n")
    tmp = tmp.replace("\r", "\\r")
    tmp = tmp.replace("\t", "\\t")
    return "'" + tmp + "'"


def convert_string(s, s2):
    """Unescape double quotes in a string token."""
    return s2[0].replace("\\\"", '"')


def convert_dict(d):
    """Convert a parsed record into a dictionary."""
    return dict(d[0])


def convert_tuple(t):
    """Convert a parsed array/tuple into a Python tuple."""
    return tuple(t[0])


def evaluate_expression(s, loc, toks):
    """Evaluate an arithmetic dimension expression or return it verbatim."""
    # Convert the tokens (ParseResults) into a string expression
    flat_list = [item for sublist in toks[0] for item in sublist]
    expr = "".join(flat_list)
    try:
        # Evaluate the expression safely
        return eval(expr)
    except (SyntaxError, NameError):
        return expr


# Number parsing (supports arithmetic expressions in dimensions) (e.g., {1 + 1, 1})
arrayDimension = infix_notation(
    Word(alphas + "_", alphanums + "_") | Word(nums),
    [
        (Word("+-", exact=1), 1, opAssoc.RIGHT),
        (Word("*/", exact=1), 2, opAssoc.LEFT),
        (Word("+-", exact=1), 2, opAssoc.LEFT),
    ],
).set_parse_action(evaluate_expression)

omcRecord = Forward()
omcValue = Forward()

# pyparsing's replace_with (and thus replace_with) has incorrect type
# annotation: https://github.com/pyparsing/pyparsing/issues/602
TRUE = Keyword("true").set_parse_action(replace_with(True))   # type: ignore
FALSE = Keyword("false").set_parse_action(replace_with(False))   # type: ignore
NONE = (Keyword("NONE") + Suppress("(") + Suppress(")")).set_parse_action(replace_with(None))  # type: ignore
SOME = (Suppress(Keyword("SOME")) + Suppress("(") + omcValue + Suppress(")"))

omcString = QuotedString(quote_char='"', esc_char='\\', multiline=True).set_parse_action(convert_string)
omcNumber = Combine(Optional('-') + ('0' | Word('123456789', nums)) +
                    Optional('.' + Word(nums)) +
                    Optional(Word('eE', exact=1) + Word(nums + '+-', nums)))

# ident = Word(alphas + "_", alphanums + "_") | Combine("'" + Word(alphanums + "!#$%&()*+,-./:;<>=?@[]^{}|~ ") + "'")
ident = (Word(alphas + "_", alphanums + "_")
         | QuotedString(quote_char='\'', esc_char='\\').set_parse_action(convert_string2))
fqident = Forward()
fqident << ((ident + "." + fqident) | ident)
omcValues = DelimitedList(omcValue)
omcTuple = Group(Suppress('(') + Optional(omcValues) + Suppress(')')).set_parse_action(convert_tuple)
omcArray = Group(Suppress('{') + Optional(omcValues) + Suppress('}')).set_parse_action(convert_tuple)
omcArraySpecialTypes = Group(Suppress('{')
                             + DelimitedList(arrayDimension)
                             + Suppress('}')).set_parse_action(convert_tuple)
omcValue << (omcString
             | omcNumber
             | omcRecord
             | omcArray
             | omcArraySpecialTypes
             | omcTuple
             | SOME
             | TRUE
             | FALSE
             | NONE
             | Combine(fqident))
recordMember = DelimitedList(Group(ident + Suppress('=') + omcValue))
omcRecord << Group(Suppress('record')
                   + Suppress(fqident)
                   + Dict(recordMember)
                   + Suppress('end')
                   + Suppress(fqident)
                   + Suppress(';')).set_parse_action(convert_dict)

omcGrammar = Optional(omcValue) + StringEnd()

omcNumber.set_parse_action(convert_numbers)


def om_parser_typed(string) -> Any:
    """Parse a typed OMC response string.

    Args:
        string: The typed OMC response (with ``record`` blocks, arrays,
            tuples and native Modelica types).

    Returns:
        The parsed Python object, or None for an empty response.
    """
    res = omcGrammar.parse_string(string)
    if len(res) == 0:
        return None
    return res[0]


parseString = om_parser_typed