import psycopg2
import time


class DataBase:
    def __init__(self, settings):

        # if 'host' not in settings:
        #     settings["host"] = 'localhost'
        if 'port' not in settings:
            settings["port"] = ''
        # if 'dbuser' not in settings:
        #     settings["dbuser"] = 'postgres'
        # try:
        #     self.settings = (
        #         "dbname='{dbname}' user='{dbuser}' host={host} password='{password}' port = '{port}'").format(
        #         dbname=settings['dbname'],
        #         dbuser=settings['dbuser'],
        #         host=settings['host'],
        #         password=settings['password'],
        #         port=settings['port'])
        # except KeyError as er:
        #     print er, "is required parameter"
        #     exit()

        self.conn = None
        self.cursor = None
        # self.connect()
        pass

    def start_transaction(self):
        answer = self.conn.autocommit
        if self.conn.autocommit:
            self.conn.autocommit = False
        return answer

    def end_transaction(self, transaction_started):
        if transaction_started:
            self.conn.commit()
            self.conn.autocommit = True
            print 'commit done'

    def roll_back(self, transaction_started):
        if transaction_started:
            self.conn.rollback()
            self.conn.commit()
            self.conn.autocommit = True

    def connect(self):

        try:
            self.conn = psycopg2.connect(self.settings)
        except psycopg2.Error as er:
            print er, "\n",
            exit()
        self.conn.autocommit = True
        self.cursor = self.conn.cursor()
        pass

    def disconnect(self):
        try:
            self.conn.close()
            self.conn = None
        except psycopg2.Error as er:
            print er
            exit()
        pass

    def get_info(self, table_name, wonted_data, search=None):
        # self.conn.autocommit = True
        self.cursor = self.conn.cursor()
        values = ""

        if isinstance(wonted_data, list):
            first = True
            for data in wonted_data:
                if first:
                    values += data
                    first = None
                else:
                    values += ',' + data
        else:
            values += wonted_data

        sql_request = 'SELECT ' + values + ' FROM ' + str(table_name) + ' WHERE deleted_at = 0'

        if search is not None:
            values = ()
            for key in search:
                first = True
                for val in search[key]:

                    values += (val,)
                    if first:
                        sql_request += " and " + key + " IN (%s"
                        first = None
                    else:
                        sql_request += ",%s"
                sql_request += ")"

        try:
            # print sql_request
            # print (self.cursor.mogrify(sql_request, values).decode('utf8'))
            self.cursor.execute(sql_request, values)
            return self.cursor.fetchall()
        except TypeError as er:
            print er
            exit()

    def insert(self, table_name, dic):
        # self.conn.autocommit = True
        self.cursor = self.conn.cursor()
        columns = []
        values = ()
        for param in dic:
            columns.append(param)
            values += (dic[param],)
        sql_request = "INSERT INTO {table} ({param}) VALUES ({s}) returning id".format(
                 table=table_name,
                 param=', '.join(columns),
                 s=', '.join(["%s"]*len(values)))
        # print (self.cursor.mogrify(sql_request, values).decode('utf8'))
        self.cursor.execute(sql_request, values)
        return self.cursor.fetchone()[0]
        pass

    def update(self, table_name, dic, identifier):
        # self.conn.autocommit = True
        # self.cursor = self.conn.cursor()
        part_of_sql_request = []
        values = ()
        sql_request = "UPDATE " + table_name + " SET"

        for column in dic:
            part = " " + column + " = %s"
            values += (str(dic[column]),)
            part_of_sql_request.append(part)
        sql_request += ' ,'.join(part_of_sql_request)
        sql_request += " WHERE deleted_at = 0 and id IN( "
        # del part_of_sql_request[:]
        for id in identifier:
            sql_request += "%s,"
            values += (id,)
            # sql_request += ")"
            # part_of_sql_request.append(part)
        sql_request += ')'
        print sql_request
        print values
        # print (self.cursor.mogrify(sql_request, values).decode('utf8'))

        try:
            self.cursor.execute(sql_request, values)
            return self.cursor.fetchone()[0]
        except psycopg2.Error as er:
            print er
        pass

    def delete(self, table_name, identifiers):

        delete_data = {
         "deleted_at": time.time()
         }
        return self.update(table_name, delete_data, identifiers)

    def full_delete(self, table_name, identifiers):
        self.conn.autocommit = True
        self.cursor = self.conn.cursor()
        sql_request = "DELETE FROM {table} where id = %s".format(
            table=table_name)
        val = ()
        val += (identifiers,)
        try:
            self.cursor.execute(sql_request, val)
            return self.cursor.fetchone()[0]
        except psycopg2.Error as er:
            print er