# -*- coding: utf-8 -*-

import math

import logging

from tuikit.events import Event, Emitter

from tuikit.widget import Widget

from tuikit.common import Coords

class TableModel(Emitter):

    def __init__(self, list_of_lists):

        self.add_events('change', Event)

        self.data = list_of_lists

        '''Get number of rows.'''

        return len(self.data)

        '''Get rows from begin to end, including begin, excluding end.'''

        return self.data[begin:end]

    def update(self, row, col, val):

        self.data[row][col] = val

class Column:

    '''Columns description.'''

    def __init__(self, title='', header=False, expand=True, sizereq=1,

        readonly=False, maxlength=None):

        '''Create column with default values.'''

        self.title = title

        '''Title is displayed in heading before first row.'''

        self.header = header

        '''Header column is highlighted, values in this column cannot be edited.'''

        self.expand = expand

        '''If true, this column will autoresize to consume any free space.'''

        self.sizereq = sizereq

        '''Size request. Meaning depends on value of expand:

        When false, sizereq is number of characters.

        When true, sizereq is relative size ratio.

        '''

        self.size = None

        '''Computed size of column.'''

        self.index = None

        '''Computed index.'''

        self.readonly = readonly

        '''If not readonly, values in this column can be changed by user.'''

        self.maxlength = maxlength

        '''Maximum length of value (for EditField).'''

class TableView(Widget):

    def __init__(self, model=None):

        Widget.__init__(self)

        self._default_size.update(20, 20)

        self.allow_focus = True

        # model

        self._model = None

        self.setmodel(model)

        self.columns = []

        self.spacing = 1

        self.rowcount = 0

        self.headsize = 1

        self.offset = Coords()

        #: Active cell (cursor)

        self.acell = Coords()

        self.add_events(

            'scroll', Event,

            'areasize', Event)

    def getmodel(self):

        return self._model

    def setmodel(self, value):

        if self._model:

            self._model.remove_handler('change', self.redraw)

        self._model = value

        if self._model:

            self._model.add_handler('change', self.redraw)

    model = property(getmodel, setmodel)

    def addcolumn(self, *args, **kwargs):

        for col in args:

            self.columns.append(col)

        if len(args) == 0:

            col = Column(**kwargs)

            self.columns.append(col)

    def compute_column_sizes(self):

        total_space = self.width - self.spacing * len(self.columns)

        no_expand_cols = [col for col in self.columns if not col.expand]

        no_expand_size = sum([col.sizereq for col in no_expand_cols])

        expand_cols = [col for col in self.columns if col.expand]

        expand_num = len(expand_cols)

        expand_size = total_space - no_expand_size

        # compute size of cols without expand

        for col in no_expand_cols:

            col.size = col.sizereq

        # compute size of cols with expand

        if no_expand_size > total_space + expand_num:

            for col in expand_cols:

                col.size = 1

        else:

            total_req = sum([col.sizereq for col in expand_cols])

            remaining_space = 0.

            for col in expand_cols:

                frac, intp = math.modf(expand_size * col.sizereq / total_req)

                col.size = int(intp)

                remaining_space += frac

                if remaining_space > 0.99:

                    remaining_space -= 1.

                    col.size += 1

        # compute indexes

        idx = 0

        for col in self.columns:

            if not col.header:

                col.index = idx

                idx += 1

    def draw_head(self, screen, x, y):

        screen.pushcolor('strong')

        for col in self.columns:

            screen.puts(x, y, col.title[:col.size])

            x += col.size + self.spacing

        screen.popcolor()

    def draw_row(self, screen, x, y, row, highlight):

        for col, data in zip(self.columns, row):

            if col.header:

                screen.pushcolor('strong')

            elif col.index in highlight:

                screen.pushcolor('active')

            else:

                screen.pushcolor('normal')

            screen.puts(x, y, data[:col.size])

            screen.popcolor()

            x += col.size + self.spacing

    def on_draw(self, ev):

        ev.driver.pushcolor('normal')

        ev.driver.fill_clip()

        numrows = min(self.rowcount - self.offset.y, self.height - self.headsize)

        self.compute_column_sizes()

        self.draw_head(ev.driver, ev.x, ev.y)

        y = ev.y + self.headsize

        for row in rows:

            highlight = []

            if self.offset.y + rows.index(row) == self.acell.y:

                highlight.append(self.acell.x)

            self.draw_row(ev.driver, ev.x, y, row, highlight)

            y += 1

        ev.driver.popcolor()

    def on_keypress(self, ev):

        key_map = {

            'up': self.move_up,

            'down': self.move_down,

            'left': self.move_left,

            'right': self.move_right,

            'pageup':  self.move_pageup,

            'pagedown':  self.move_pagedown}

        if ev.keyname in key_map:

            key_map[ev.keyname]()

            self.redraw()

            return True

    def set_yofs(self, yofs):

        if yofs > self.rowcount - (self.height - self.headsize):

            yofs = self.rowcount - (self.height - self.headsize)

        if yofs < 0:

            yofs = 0

        self.offset.y = yofs

        self.emit('scroll')

    def move_up(self):

        if self.acell.y > 0:

            self.acell.y -= 1

            if self.acell.y < self.offset.y:

                self.set_yofs(self.acell.y)

            return True

        return False

    def move_down(self):

        log=logging.getLogger('tuikit')

        log.debug('height %d', self.height)

        if self.acell.y < self.rowcount - 1:

            self.acell.y += 1

            if self.acell.y > self.offset.y + (self.height - self.headsize - 1):

                self.set_yofs(self.acell.y - (self.height - self.headsize - 1))

            return True

        return False

    def move_pageup(self):

        if self.acell.y >= self.height - self.headsize - 1:

            self.acell.y -= self.height - self.headsize - 1

            self.set_yofs(self.offset.y - (self.height - self.headsize - 1))

        else:

            self.acell.y = 0

            self.set_yofs(0)

    def move_pagedown(self):

        if self.acell.y <= self.rowcount - (self.height - self.headsize - 1):

            self.acell.y += self.height - self.headsize - 1

            self.set_yofs(self.offset.y + (self.height - self.headsize - 1))

        else:

            self.acell.y = self.rowcount - 1

            self.set_yofs(self.acell.y)

    def move_left(self):

        if self.acell.x > 0:

            self.acell.x -= 1

            return True

        return False

    def move_right(self):

        if self.acell.x < len([col for col in self.columns if not col.header]) - 1:

            self.acell.x += 1

            return True

        return False