#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3
from flask import g
import ConfigParser
from mfrontend import utils, exceptions
from contextlib import closing
import os.path

config = ConfigParser.SafeConfigParser()
config.read('config.ini')

## Opisy wszystkich stanów zadań
states = {0 : u'Oczekujące',
          1 : u'Trwa',
          2 : u'Zakończone'}

def connect_db():
    """Funkcja łącząca się z bazą danych."""
    g.db = sqlite3.connect(config.get('Basic','Database'))

def disconnect_db():
    """Funkcja zamykająca połączenie z bazą danych"""
    g.db.close()

def init_db():
    """Funkcja przeprowadzająca inicjalizację bazy danych zgodnie
       z plikiem schema.sql. Na podstawie kodu ze strony
       http://flask.pocoo.org/docs/patterns/sqlite3/#initial-schemas
       Instalacja powiedzie się tylko wtedy, gdy w obecnym katalogu
       nie istnieje plik '.installed'. Plik taki jest tworzony
       po każdej instalacji, aby zapobiec operacjom na
       istniejących bazach.
       @return True, jeśli instalacja została wykonana,
               False, jeśli plik '.installed' istnieje.
    """
    if not os.path.isfile('.installed'):
        with open('schema.sql', 'r') as f:
            g.db.cursor().executescript(f.read())
        g.db.commit()
        open('.installed', 'w').close()
        return True
    else:
        return False

def query_db(query, args=(), one=False):
    """Funkcja ułatwiająca odpytywanie bazy danych, źródło:
       http://flask.pocoo.org/docs/patterns/sqlite3/
    """
    cur = g.db.execute(query, args)
    rv = [dict((cur.description[idx][0], value)
               for idx, value in enumerate(row)) for row in cur.fetchall()]
    return (rv[0] if rv else None) if one else rv

def user_can_login(username, password):
    """Funkcja sprawdzająca, czy podany użytkownik może sie zalogować
       po podaniu danego w argumencie hasła.
       @param username Nazwa użytkownika
       @param password Hasło
       @return Prawda, jeśli podane dane są akceptowalne, w przeciwnym
       razie fałsz.
    """
    user = query_db('select * from users where username = ?',
                   [username], one=True)
    if user is None:    # Brak użytkownika o takiej nazwie
        return False
    if user['password'] == utils.hashPassword(password):
        if not user['activated']:
            raise exceptions.UserNotActivated()
        return True     # Jeśli aktywny i hasło dobre, to wpuszczamy
    # Najwyraźniej jest taki użytkownik, ale hasło się nie zgadza
    return False

def register_user(username, password):
    """Funkcja rejestrująca nowego użytkownika w systemie.
       @param username Nazwa nowego użytkownika
       @param password Hasło w czystym tekście, funkcja sama
                       zajmie się hashowaniem
    """
    user = query_db('select * from users where username = ?;',
                    [username], one=True)
    if user is not None:
        raise exceptions.UserExists
    hashedPassword = utils.hashPassword(password)
    # teraz właściwe dodawanie danych do bazy
    query_db('INSERT INTO users (username, password, activated) VALUES (?,?,0);',
            [username, hashedPassword])
    g.db.commit()

def get_jobs(owner_id, hash, state):
    """Funkcja pobiera informacje o zadaniach. Możliwe jest filtrowanie zadań.
       @param owner_id  Pobiera informacje jedynie o zadaniach stworzonych przez
                        użytkownika o podanym id. Jeśli parametr ten jest ustawiony
                        na None, to pobiera zadania wszystkich użytkowników.
       @param hash      Pobiera informacje o zadaniu o podanym hashu. Jeśli jest ustawione
                        na None, to pobiera informacje o wszystkich hashach.
       @param state     Pobiera informacje o zadaniach będących w określonym stanie.
                        Jeśli jest ustawione na None, to pobiera informację o zadaniach
                        znajdujących się w każdym stanie.
       @return Informacje o zadaniach z uwzględnieniem podanych w parametrach filtrów.
    """
    parameters = []
    sqlLine = ""
    if owner_id is not None:
        sqlLine += "owner_id = ?"
        parameters.append(owner_id)
    if hash is not None:
        if not sqlLine == "":
            sqlLine += " AND "
        sqlLine += "hash = ?"
        parameters.append(hash)
    if state is not None:
        if not sqlLine == "":
            sqlLine += " AND "
        sqlLine += "state = ?"
        parameters.append(state)
    if sqlLine == "":
        sqlLine = "select * from jobs;"
    else:
        sqlLine = "select * from jobs where " + sqlLine + ";"
    result = query_db(sqlLine,parameters)
    # teraz trochę upiększamy wynik, np. pobierając nazwy użytkowników
    for job in result:
        job['username'] = get_user_name(job['owner_id'])
        job['state_text'] = states[job['state']]
    return result

def get_user_name(user_id):
    """ Funkcja pobiera nazwę użytkownika o podanym identyfikatorze.
        @param user_id  Identyfikator użytkownika, którego nazwa jest pożądana.
        @return String zawierający nazwę użytkownika, lub None, jeśli użytkownik nie istnieje.
    """
    return query_db("SELECT username FROM users WHERE id = ?;",
                    [user_id], one=True)["username"]

def get_user_id(user_name):
    """ Funkcja pobiera identyfikator użytkownika na podstawie nazwy.
        @param user_name    Nazwa użytkownika, którego indentyfikator ma zostać zwrócony.
        @return             Identyfikator użytkownika.
    """
    return query_db("SELECT id FROM users WHERE username = ?;",
                    [user_name], one=True)["id"]

def new_job(id, label, hash):
    query_db("INSERT INTO jobs (owner_id, label, hash) VALUES (?,?,?);",
            [id, label, hash])
    g.db.commit()