# -*- coding: utf-8 -*-
'''SDL driver.

Requires C++ extension module.
See sdlterm directory.

'''

from tuikit.driver_base import Driver

import logging
import subprocess

import sys
sys.path.insert(0, 'sdlterm/build/lib.linux-x86_64-3.2')
from sdlterm import SDLTerminal


class DriverSDL(Driver):

    '''SDL driver class'''

    color_map = {
        'black'         : 0,
        'blue'          : 1,
        'green'         : 2,
        'cyan'          : 3,
        'red'           : 4,
        'magenta'       : 5,
        'brown'         : 6,
        'lightgray'     : 7,
        'gray'          : 8,
        'lightblue'     : 9,
        'lightgreen'    : 10,
        'lightcyan'     : 11,
        'lightred'      : 12,
        'lightmagenta'  : 13,
        'yellow'        : 14,
        'white'         : 15,
    }

    style_map = {
        'bold'      : 1 << 24,  # bold font
        'underline' : 1 << 25,  # underline text
        'standout'  : 1 << 26,  # inverse bg/fg
        'blink'     : 1 << 27,  # blinking text
    }

    def __init__(self):
        '''Initialize instance attributes'''
        Driver.__init__(self)
        self.log = logging.getLogger('tuikit')
        self.sdlterm = SDLTerminal()
        self.colors = {}     # maps names to attributes
        self.colorstack = [] # pushcolor/popcolor puts or gets attributes from this

    def start(self, mainfunc):
        '''Start driver and run mainfunc.'''
        self.select_system_font()
        self.sdlterm.resize(800, 600)
        self.size.w, self.size.h = self.sdlterm.width, self.sdlterm.height
        mainfunc()


    ## input ##

    def getevents(self, timeout=None):
        '''Process input, return list of events.

        timeout -- float, in seconds

        '''
        if timeout is not None:
            timeout = int(timeout*1000)
        event = self.sdlterm.wait_event(timeout)
        if not event:
            return []
        if event[0] == 'resize':
            self.size.w, self.size.h = self.sdlterm.width, self.sdlterm.height
        return [event]


    ## drawing ##

    def erase(self):
        '''Clear screen.'''
        self.sdlterm.erase()

    def putch(self, x, y, c):
        '''Output one unicode character to specified coordinates.'''
        if not self.clipstack.test(x, y):
            return
        self.sdlterm.putch(x, y, c)

    def commit(self):
        '''Commit changes to the screen.'''
        self.sdlterm.commit()


    ## colors ##

    def defcolor(self, name, desc):
        '''Define color name.'''
        parts = desc.split(',')
        fgbg = parts[0].split(' on ', 1)
        fg = fgbg[0]
        bg = fgbg[1:] and fgbg[1] or 'black'
        style = parts[1:]
        fg = self._color_by_name(fg)
        bg = self._color_by_name(bg)
        style = self._style_by_names(style)
        self.colors[name] = self.sdlterm.prepare_attr(fg, bg, style);

    def setcolor(self, name):
        """Set defined color. Previous color is forgotten."""
        self.sdlterm.set_attr(self.colors[name])

    def pushcolor(self, name):
        '''Add color on top of stack and use this color for following output.'''
        if len(self.colorprefix):
            prefixname = self.colorprefix[-1] + name
            if prefixname in self.colors:
                name = prefixname
        attr = self.colors[name]
        self.sdlterm.set_attr(attr)
        self.colorstack.append(attr)

    def popcolor(self):
        '''Remove color from top of stack and use new top color for following output.'''
        self.colorstack.pop()
        if len(self.colorstack):
            attr = self.colorstack[-1]
        else:
            attr = 7
        self.sdlterm.set_attr(attr)

    def _color_by_name(self, name):
        name = name.lower().strip()
        return self.color_map[name]

    def _style_by_names(self, names):
        style = 0
        for name in names:
            name = name.lower().strip()
            style |= self.style_map[name]
        return style


    ## cursor ##

    def showcursor(self, x, y):
        '''Set cursor to be shown at x, y coordinates.'''
        if not self.clipstack.test(x, y):
            return
        self.sdlterm.show_cursor(x, y)

    def hidecursor(self):
        '''Hide cursor.'''
        self.sdlterm.hide_cursor()

    ## private utility ##

    def _lookup_system_font(self, family, style):
        """Find system font by family name and style.

        style -- font style: 'normal', 'bold'

        Returns font file name.

        Uses fontconfig, it must be installed in system.

        """
        return subprocess.check_output([
            'fc-match',
            '%s:style=%s:fontformat=truetype:spacing=mono' % (family, style),
            '-f%{file}'])

    def select_system_font(self, family='monospace'):
        """Search for system fonts by family name and use them.

        Example family names:
            'monospace' - default monospace system font
            'DejaVu Sans Mono'
            'Liberation Mono'
        """
        fname_regular = self._lookup_system_font(family, 'normal')
        fname_bold = self._lookup_system_font(family, 'bold')
        self.log.info('DriverSDL: using fonts:\n%s\n%s', fname_regular.decode(), fname_bold.decode())
        self.sdlterm.select_font(fname_regular, fname_bold, 12)


driverclass = DriverSDL