import datetime
import traceback
import MySQLdb.cursors

from db.parser import parse


class Cursor:
  def __init__(self, connection, internal):
    self.connection = connection
    self.typebytype = self.connection.pool.server.dbtypebytype
    self.typebychar = self.connection.pool.server.dbtypebychar
    self.internal = internal
    self.entered = None
    self.iterator = None

  def get_internal(self):
    return self.internal if self.entered is None else self.entered

  def __enter__(self):
    self.entered = self.internal.__enter__()
    return self

  def __exit__(self, exc_type, exc_value, traceback):
    self.entered.__exit__(exc_type, exc_value, traceback)
    self.entered = None

  def __iter__(self):
    self.iterator = iter(self.get_internal())
    return self

  def __next__(self):
    data = next(self.iterator)
    if type(data) is dict:
      for k, v in data.items():
        t = self.typebytype.get( type(v) )
        if t: data[k] = t.from_db(self, v)
    else:
      orig = data
      data = list()
      for v in orig:
        t = self.typebytype.get( type(v) )
        data.append(t.from_db(self, v) if t else v)
    return data
  
  def execute(self, sql = None, *args, **kvargs):
    if args or kvargs:
      sql = parse(self.typebychar, self.connection, sql, *args, **kvargs)
    self.get_internal().execute(sql)


class Connection:
  def __init__(self, pool, internal, readonly = True):
    self.pool = pool
    self.internal = internal
    self.readonly = readonly
    self.finished = True
    self.begin()

  def cursor(self, as_dict = False):
    assert not self.finished
    cursorclass = MySQLdb.cursors.DictCursor if as_dict else MySQLdb.cursors.Cursor
    cursor = Cursor(self, self.internal.cursor(cursorclass))
    return cursor
  def cursor_list(self):
    return self.cursor(False)
  def cursor_dict(self):
    return self.cursor(True)
  
  def query(self, as_dict, sql = None, *args, **kvargs):
    with self.cursor(as_dict) as cursor:
      cursor.execute(sql, *args, **kvargs)
      return list(cursor)
  def query_list(self, sql = None, *args, **kvargs):
    return self.query(False, sql, *args, **kvargs)
  def query_dict(self, sql = None, *args, **kvargs):
    return self.query(True, sql, *args, **kvargs)

  def execute(self, sql = None, *args, **kvargs):
    with self.cursor() as cursor:
      cursor.execute(sql, *args, **kvargs)

  def insert_id(self, *args, **kwargs):
    assert not self.finished
    return self.internal.insert_id(*args, **kwargs)
  
  def escape(self, *args, **kwargs):
    r = self.internal.escape(*args, **kwargs)
    return r.decode("utf8") if type(r) is bytes else r

  def escape_string(self, *args, **kwargs):
    r = self.internal.escape_string(*args, **kwargs)
    return r.decode("utf8") if type(r) is bytes else r
  
  def begin(self):
    assert self.finished
    self.finished = False
    if self.readonly:
      self.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ")
      self.execute("START TRANSACTION READ ONLY, WITH CONSISTENT SNAPSHOT")
    else:
      self.execute("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
      self.execute("START TRANSACTION READ WRITE, WITH CONSISTENT SNAPSHOT")
    self.now = datetime.datetime.now(datetime.timezone.utc)

  def commit(self):
    assert not self.finished
    self.internal.commit()
    self.finished = True
  
  def rollback(self):
    assert not self.finished
    self.internal.rollback()
    self.finished = True
      
  def release(self):
    if not self.finished:
      try: self.rollback()
      except Exception as e:
        print(traceback.format_exc())
        print(e)