# vim:set et sts=4 sw=4:
#
# ibus - The Input Bus
#
# Copyright (c) 2007-2010 Peng Huang <shawn.p.huang@gmail.com>
# Copyright (c) 2007-2010 Red Hat, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
# USA

__all__ = (
        "LookupTable",
    )

import dbus
from common import *
from serializable import *
from exception import *

class LookupTable(Serializable):
    __gtype_name__ = "PYIBusLookupTable"
    __NAME__ = "IBusLookupTable"
    def __init__(self, page_size=5, cursor_pos=0, coursor_visible=True, round=False,
        orientation=ORIENTATION_SYSTEM, candidates=None, labels=None):
        super(LookupTable, self).__init__()
        self.__cursor_pos = cursor_pos
        self.__cursor_visible = True
        self.__round = round
        self.__orientation = orientation
        if candidates == None:
            self.__candidates = list()
        else:
            self.__candidates = candidates
        self.set_page_size(page_size)
        self.set_labels(labels)

    def set_page_size(self, page_size):
        self.__page_size = page_size

    def get_page_size(self):
        return self.__page_size

    def get_current_page_size(self):
        nr_candidate = len(self.__candidates)
        nr_page, last_page_size = divmod(nr_candidate, self.__page_size)
        if self.__cursor_pos / self.__page_size == nr_page:
            return last_page_size
        else:
            return self.__page_size

    def set_labels(self, labels):
        if labels == None:
            self.__labels = list()
        else:
            self.__labels = labels

    def get_labels(self):
        return self.__labels

    def show_cursor(self, show=True):
        self.__cursor_visible = show

    def is_cursor_visible(self):
        return self.__cursor_visible

    def get_current_page_start(self):
        return (self.__cursor_pos / self.__page_size) * self.__page_size

    def set_cursor_pos(self, pos):
        if pos >= len(self.__candidates) or pos < 0:
            return False
        self.__cursor_pos = pos
        return True

    def get_cursor_pos(self):
        return self.__cursor_pos

    def get_cursor_pos_in_current_page(self):
        page, pos_in_page = divmod(self.__cursor_pos, self.__page_size)
        return pos_in_page

    def set_cursor_pos_in_current_page(self, pos):
        if pos < 0 or pos >= self.__page_size:
            return False
        pos += self.get_current_page_start()
        if pos >= len(self.__candidates):
            return False
        self.__cursor_pos = pos
        return True
    def set_orientation(self, orientation):
        self.__orientation = orientation

    def get_orientation(self):
        return self.__orientation

    def page_up(self):
        if self.__cursor_pos < self.__page_size:
            if self.__round:
                nr_candidates = len(self.__candidates)
                max_page = nr_candidates / self.__page_size
                self.__cursor_pos += max_page * self.__page_size
                if self.__cursor_pos > nr_candidates - 1:
                    self.__cursor_pos = nr_candidates - 1
                return True
            else:
                return False

        self.__cursor_pos -= self.__page_size
        return True

    def page_down(self):
        current_page = self.__cursor_pos / self.__page_size
        nr_candidates = len(self.__candidates)
        max_page = nr_candidates / self.__page_size

        if current_page >= max_page:
            if self.__round:
                self.__cursor_pos %= self.__page_size
                return True
            else:
                return False

        pos = self.__cursor_pos + self.__page_size
        if pos >= nr_candidates:
            pos = nr_candidates - 1
        self.__cursor_pos = pos

        return True

    def cursor_up(self):
        if self.__cursor_pos == 0:
            if self.__round:
                self.__cursor_pos = len(self.__candidates) - 1
                return True
            else:
                return False

        self.__cursor_pos -= 1
        return True

    def cursor_down(self):
        if self.__cursor_pos == len(self.__candidates) - 1:
            if self.__round:
                self.__cursor_pos = 0
                return True
            else:
                return False

        self.__cursor_pos += 1
        return True

    def clean(self):
        self.__candidates = list()
        self.__cursor_pos = 0

    def append_candidate(self, text):
        self.__candidates.append(text)

    def get_candidate(self, index):
        return self.__candidates[index]

    def append_label(self, text):
        self.__labels.append(text)

    def get_label(self, index):
        return self.__labels[index]

    def get_candidates_in_current_page(self):
        page = self.__cursor_pos / self.__page_size
        start_index = page * self.__page_size
        end_index = min((page + 1) * self.__page_size, len(self.__candidates))
        return self.__candidates[start_index:end_index]

    def get_current_candidate(self):
        return self.__candidates [self.__cursor_pos]

    def get_number_of_candidates(self):
        return len(self.__candidates)

    def __len__(self):
        return self.get_number_of_candidates()

    def serialize(self, struct):
        super(LookupTable, self).serialize(struct)
        struct.append(dbus.UInt32(self.__page_size))
        struct.append(dbus.UInt32(self.__cursor_pos))
        struct.append(dbus.Boolean(self.__cursor_visible))
        struct.append(dbus.Boolean(self.__round))
        struct.append(dbus.Int32(self.__orientation))
        candidates = map(lambda c: serialize_object(c), self.__candidates)
        struct.append(dbus.Array(candidates, signature="v"))
        labels = map(lambda c: serialize_object(c), self.__labels)
        struct.append(dbus.Array(labels, signature="v"))


    def get_current_page_as_lookup_table(self):
        candidates = self.get_candidates_in_current_page()
        return LookupTable(self.__page_size,
                           self.__cursor_pos % self.__page_size,
                           self.__cursor_visible,
                           self.__round,
                           self.__orientation,
                           candidates,
                           self.__labels)

    def deserialize(self, struct):
        super(LookupTable, self).deserialize(struct)

        self.__page_size = struct.pop(0)
        self.__cursor_pos = struct.pop(0)
        self.__cursor_visible = struct.pop(0)
        self.__round = struct.pop(0)
        self.__orientation = struct.pop(0)
        self.__candidates = map(deserialize_object, struct.pop(0))
        self.__labels = map(deserialize_object, struct.pop(0))

def test():
    t = LookupTable()
    # attrs = AttrList()
    # attrs.append(AttributeBackground(RGB(233, 0,1), 0, 3))
    # attrs.append(AttributeUnderline(1, 3, 5))
    t.append_candidate("Hello")
    value = serialize_object(t)
    t = deserialize_object(value)
    t = t.get_current_page_as_lookup_table()
    value = serialize_object(t)
    t = deserialize_object(value)

if __name__ == "__main__":
    test()