# Copyright 2008-2017 Free Software Foundation, Inc.
# This file is part of GNU Radio
#
# GNU Radio Companion is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# GNU Radio Companion is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

from __future__ import absolute_import

import ast
import collections
import textwrap

import six
from six.moves import range

from .. import Constants
from ..base import Element
from ..utils.descriptors import Evaluated, EvaluatedEnum, setup_names

from . import dtypes
from .template_arg import TemplateArg

attributed_str = type('attributed_str', (str,), {})

@setup_names
class Param(Element):

    is_param = True

    name = Evaluated(str, default='no name')
    dtype = EvaluatedEnum(Constants.PARAM_TYPE_NAMES, default='raw')
    hide = EvaluatedEnum('none all part')

    # region init
    def __init__(self, parent, id, label='', dtype='raw', default='',
                 options=None, option_labels=None, option_attributes=None,
                 category='', hide='none', **_):
        """Make a new param from nested data"""
        super(Param, self).__init__(parent)
        self.key = id
        self.name = label.strip() or id.title()
        self.category = category or Constants.DEFAULT_PARAM_TAB

        self.dtype = dtype
        self.value = self.default = str(default)

        self.options = self._init_options(options or [], option_labels or [],
                                          option_attributes or {})
        self.hide = hide or 'none'
        # end of args ########################################################

        self._evaluated = None
        self._stringify_flag = False
        self._lisitify_flag = False
        self.hostage_cells = set()
        self._init = False
        self.scale = {
            'E': 1e18,
            'P': 1e15,
            'T': 1e12,
            'G': 1e9,
            'M': 1e6,
            'k': 1e3,
            'm': 1e-3,
            'u': 1e-6,
            'n': 1e-9,
            'p': 1e-12,
            'f': 1e-15,
            'a': 1e-18,
        }
        self.scale_factor = None
        self.number = None

    def _init_options(self, values, labels, attributes):
        """parse option and option attributes"""
        options = collections.OrderedDict()
        options.attributes = collections.defaultdict(dict)

        padding = [''] * max(len(values), len(labels))
        attributes = {key: value + padding for key, value in six.iteritems(attributes)}

        for i, option in enumerate(values):
            # Test against repeated keys
            if option in options:
                raise KeyError('Value "{}" already exists in options'.format(option))
            # get label
            try:
                label = str(labels[i])
            except IndexError:
                label = str(option)
            # Store the option
            options[option] = label
            options.attributes[option] = {attrib: values[i] for attrib, values in six.iteritems(attributes)}

        default = next(iter(options)) if options else ''
        if not self.value:
            self.value = self.default = default

        if self.is_enum() and self.value not in options:
            self.value = self.default = default  # TODO: warn
            # raise ValueError('The value {!r} is not in the possible values of {}.'
            #                  ''.format(self.get_value(), ', '.join(self.options)))
        return options
    # endregion

    @property
    def template_arg(self):
        return TemplateArg(self)

    def __str__(self):
        return 'Param - {}({})'.format(self.name, self.key)

    def __repr__(self):
        return '{!r}.param[{}]'.format(self.parent, self.key)

    def is_enum(self):
        return self.get_raw('dtype') == 'enum'

    def get_value(self):
        value = self.value
        if self.is_enum() and value not in self.options:
            value = self.default
            self.set_value(value)
        return value

    def set_value(self, value):
        # Must be a string
        self.value = str(value)

    def set_default(self, value):
        if self.default == self.value:
            self.set_value(value)
        self.default = str(value)

    def rewrite(self):
        Element.rewrite(self)
        del self.name
        del self.dtype
        del self.hide

        self._evaluated = None
        try:
            self._evaluated = self.evaluate()
        except Exception as e:
            self.add_error_message(str(e))

        rewriter = getattr(dtypes, 'rewrite_' + self.dtype, None)
        if rewriter:
            rewriter(self)

    def validate(self):
        """
        Validate the param.
        The value must be evaluated and type must a possible type.
        """
        Element.validate(self)
        if self.dtype not in Constants.PARAM_TYPE_NAMES:
            self.add_error_message('Type "{}" is not a possible type.'.format(self.dtype))

        validator = dtypes.validators.get(self.dtype, None)
        if self._init and validator:
            try:
                validator(self)
            except dtypes.ValidateError as e:
                self.add_error_message(str(e))

    def get_evaluated(self):
        return self._evaluated

    def is_float(self, num):
        """
        Check if string can be converted to float.

        Returns:
            bool type
        """
        try:
            float(num)
            return True
        except ValueError:
            return False

    def evaluate(self):
        """
        Evaluate the value.

        Returns:
            evaluated type
        """
        self._init = True
        self._lisitify_flag = False
        self._stringify_flag = False
        dtype = self.dtype
        expr = self.get_value()
        scale_factor = self.scale_factor

        #########################
        # ID and Enum types (not evaled)
        #########################
        if dtype in ('id', 'stream_id','name') or self.is_enum():
            if self.options.attributes:
                expr = attributed_str(expr)
                for key, value in self.options.attributes[expr].items():
                    setattr(expr, key, value)
            return expr

        #########################
        # Numeric Types
        #########################
        elif dtype in ('raw', 'complex', 'real', 'float', 'int', 'hex', 'bool'):
            if expr:
                try:
                    if isinstance(expr, str) and self.is_float(expr[:-1]):
                            scale_factor = expr[-1:]
                            if scale_factor in self.scale:
                                expr = str(float(expr[:-1])*self.scale[scale_factor])
                    value = self.parent_flowgraph.evaluate(expr)
                except Exception as e:
                    raise Exception('Value "{}" cannot be evaluated:\n{}'.format(expr, e))
            else:
                value = 0
            if dtype == 'hex':
                value = hex(value)
            elif dtype == 'bool':
                value = bool(value)
            return value

        #########################
        # Numeric Vector Types
        #########################
        elif dtype in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):
            if not expr:
                return []   # Turn a blank string into an empty list, so it will eval
            try:
                value = self.parent.parent.evaluate(expr)
            except Exception as value:
                raise Exception('Value "{}" cannot be evaluated:\n{}'.format(expr, value))
            if not isinstance(value, Constants.VECTOR_TYPES):
                self._lisitify_flag = True
                value = [value]
            return value
        #########################
        # String Types
        #########################
        elif dtype in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):
            # Do not check if file/directory exists, that is a runtime issue
            try:
                # Do not evaluate multiline strings (code snippets or comments)
                if dtype not in ['_multiline','_multiline_python_external']:
                    value = self.parent_flowgraph.evaluate(expr)
                    if not isinstance(value, str):
                        raise Exception()
                else:
                    value = str(expr)
            except Exception:
                self._stringify_flag = True
                value = str(expr)
            if dtype == '_multiline_python_external':
                ast.parse(value)  # Raises SyntaxError
            return value
        #########################
        # GUI Position/Hint
        #########################
        elif dtype == 'gui_hint':
            return self.parse_gui_hint(expr) if self.parent_block.state == 'enabled' else ''
        #########################
        # Import Type
        #########################
        elif dtype == 'import':
            # New namespace
            n = dict()
            try:
                exec(expr, n)
            except ImportError:
                raise Exception('Import "{}" failed.'.format(expr))
            except Exception:
                raise Exception('Bad import syntax: "{}".'.format(expr))
            return [k for k in list(n.keys()) if str(k) != '__builtins__']

        #########################
        else:
            raise TypeError('Type "{}" not handled'.format(dtype))

    def to_code(self):
        """
        Convert the value to code.
        For string and list types, check the init flag, call evaluate().
        This ensures that evaluate() was called to set the xxxify_flags.

        Returns:
            a string representing the code
        """
        self._init = True
        value = self.get_value()
        # String types
        if self.dtype in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):
            if not self._init:
                self.evaluate()
            return repr(value) if self._stringify_flag else value

        # Vector types
        elif self.dtype in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):
            if not self._init:
                self.evaluate()
            return '[' + value + ']' if self._lisitify_flag else value
        else:
            return value

    def get_opt(self, item):
        return self.options.attributes[self.get_value()][item]

    ##############################################
    # GUI Hint
    ##############################################
    def parse_gui_hint(self, expr):
        """
        Parse/validate gui hint value.

        Args:
            expr: gui_hint string from a block's 'gui_hint' param

        Returns:
            string of python code for positioning GUI elements in pyQT
        """
        self.hostage_cells.clear()

        # Parsing
        if ':' in expr:
            tab, pos = expr.split(':')
        elif ',' in expr:
            tab, pos = '', expr
        else:
            tab, pos = expr, ''

        if '@' in tab:
            tab, index = tab.split('@')
        else:
            index = '0'
        index = int(index)

        # Validation
        def parse_pos():
            e = self.parent_flowgraph.evaluate(pos)

            if not isinstance(e, (list, tuple)) or len(e) not in (2, 4) or not all(isinstance(ei, int) for ei in e):
                raise Exception('Invalid GUI Hint entered: {e!r} (Must be a list of {{2,4}} non-negative integers).'.format(e=e))

            if len(e) == 2:
                row, col = e
                row_span = col_span = 1
            else:
                row, col, row_span, col_span = e

            if (row < 0) or (col < 0):
                raise Exception('Invalid GUI Hint entered: {e!r} (non-negative integers only).'.format(e=e))

            if (row_span < 1) or (col_span < 1):
                raise Exception('Invalid GUI Hint entered: {e!r} (positive row/column span required).'.format(e=e))

            return row, col, row_span, col_span

        def validate_tab():
            tabs = (block for block in self.parent_flowgraph.iter_enabled_blocks()
                    if block.key == 'qtgui_tab_widget' and block.name == tab)
            tab_block = next(iter(tabs), None)
            if not tab_block:
                raise Exception('Invalid tab name entered: {tab} (Tab name not found).'.format(tab=tab))

            tab_index_size = int(tab_block.params['num_tabs'].value)
            if index >= tab_index_size:
                raise Exception('Invalid tab index entered: {tab}@{index} (Index out of range).'.format(
                    tab=tab, index=index))

        # Collision Detection
        def collision_detection(row, col, row_span, col_span):
            my_parent = '{tab}@{index}'.format(tab=tab, index=index) if tab else 'main'
            # Calculate hostage cells
            for r in range(row, row + row_span):
                for c in range(col, col + col_span):
                    self.hostage_cells.add((my_parent, (r, c)))

            for other in self.get_all_params('gui_hint'):
                if other is self:
                    continue
                collision = next(iter(self.hostage_cells & other.hostage_cells), None)
                if collision:
                    raise Exception('Block {block!r} is also using parent {parent!r}, cell {cell!r}.'.format(
                        block=other.parent_block.name, parent=collision[0], cell=collision[1]
                    ))

        # Code Generation
        if tab:
            validate_tab()
            if not pos:
                layout = '{tab}_layout_{index}'.format(tab=tab, index=index)
            else:
                layout = '{tab}_grid_layout_{index}'.format(tab=tab, index=index)
        else:
            layout = 'top_grid_layout'

        widget = '%s'  # to be fill-out in the mail template

        if pos:
            row, col, row_span, col_span = parse_pos()
            collision_detection(row, col, row_span, col_span)

            widget_str = textwrap.dedent("""
                self.{layout}.addWidget({widget}, {row}, {col}, {row_span}, {col_span})
                for r in range({row}, {row_end}):
                    self.{layout}.setRowStretch(r, 1)
                for c in range({col}, {col_end}):
                    self.{layout}.setColumnStretch(c, 1)
            """.strip('\n')).format(
                layout=layout, widget=widget,
                row=row, row_span=row_span, row_end=row+row_span,
                col=col, col_span=col_span, col_end=col+col_span,
            )

        else:
            widget_str = 'self.{layout}.addWidget({widget})'.format(layout=layout, widget=widget)

        return widget_str

    def get_all_params(self, dtype, key=None):
        """
        Get all the params from the flowgraph that have the given type and
        optionally a given key

        Args:
            dtype: the specified type
            key: the key to match against

        Returns:
            a list of params
        """
        params = []
        for block in self.parent_flowgraph.iter_enabled_blocks():
            params.extend(
                param for param in block.params.values()
                if param.dtype == dtype and (key is None or key == param.name)
            )
        return params
