import time
from time import time

class OperationClass:

     def __init__(self):
          pass

     def connectDB(self):
          pass

     def disconnectDB(self):
          pass

     def insertJsonFromDirPath(self, path_source, type_db):
          import json
          import glob
          json_data = []
          path_files = glob.glob(path_source+'\\*')
          try:
               if type_db == 'PostgreSQL':
                    for path_file in path_files:
                         with open(path_file,'r') as json_file:
                              json_data.append(json.load(json_file))
                    self.jsonIn(json_data)

          except:
               return(0)
          return(True)

     def insertImagesFromDirPath(self, path_source, path_target):
          import ntpath
          from ntpath import basename
          import glob

          path_files = glob.glob(path_source+'\\*')
          self.__deleteFilesTarget(path_target, glob.glob)
          count = 0
          try:
               for path_file in path_files:
                    count = count + 1
                    self.doInsert(path_file, ntpath.basename(path_file), count)
          except:
                    return(0)
          return(True)

     def jsonIn(self, json_list):
          pass

     def doInsert(self, path_file, file_name, count):
          pass

     def extractAllImages(self):
          pass

     def clearTable(self):
          pass

     def getTime(self):
          pass

     def __deleteFilesTarget(self, path_target, glob):
          import os
          from os import unlink
          files = glob(path_target+'\\*')
          for fl in files:
               unlink(fl)

class RunDB:

     def __init__(self, path_source, path_target, type_db):
          self.__path_source = path_source
          self.__path_target = path_target
          self.__type_db = type_db

     def defineDB(self):
          if self.__type_db == 'MySQL':
               self.__objDB = MySQL(self.__path_source, self.__path_target)
          elif self.__type_db == 'Cassandra':
               self.__objDB = Cassandra(self.__path_source, self.__path_target)
          elif self.__type_db == 'PostgreSQL':
               self.__objDB = PostgreSQL(self.__path_source, self.__path_target)
          elif self.__type_db == 'MongoDB':
               self.__objDB = MongoDB(self.__path_source, self.__path_target)
          else:
               return(1)

          if self.__objDB is None:
               return(2)
          else:
               try:
                    self.__objDB.connectDB()
               except:
                    return(3)
          return(True)

     def insertImageInDB(self):
          self.__objDB.clearTable()
          return(self.__objDB.insertImagesFromDirPath(self.__path_source, self.__path_target))

     def insertJsonInDB(self):
          return(self.__objDB.insertJsonFromDirPath(self.__path_source,self.__type_db))

     def extractImageFromDB(self):
          return(self.__objDB.extractAllImages())

     def disconnectDB(self):
          self.__objDB.disconnectDB()

     def getTime(self):
          return(self.__objDB.getTime()

class PostgreSQL(OperationClass):

     def __init__(self, path_source, path_target):
          self.__path_source = path_source
          self.__path_target = path_target
          self.__ins_query = 'INSERT INTO tab_data(data_file,name_file) VALUES(%s,%s)'
          self.__ins_js_query = 'INSERT INTO tab_json(color) VALUES(%s)'
          self.__clr_tab = 'TRUNCATE TABLE tab_data'
          self.__extract_all = 'SELECT data_file,name_file FROM tab_data'
          self.__timeSum = {'timeInsert':0,'timeExtract':0}

     def connectDB(self):
          sql = self.__importPostgre()
          self.__conn = sql.connect(host = 'localhost', port = '5433', dbname = 'postgres', user = 'postgres', password = 'ale89')
          self.__cur = self.__conn.cursor()

     def disconnectDB(self):
          self.__conn.close()

     def doInsert(self,path_file, file_name, count):
          self.__insertBlobImage(path_file, file_name)

     def jsonIn(self,json_list):
          self.__insertJson(json_list)

     def __insertBlobImage(self, path_file, file_name):
          blob = open(path_file,'rb').read()
          args = (blob,file_name,)
          begin_time = time()
          self.__cur.execute(self.__ins_query,args)
          self.__conn.commit()
          end_time = time()
          self.__timeSum['timeInsert'] += (end_time - begin_time)

     def __insertJson(self, json_list):
          js = {}
          for indx,x in enumerate(json_list):
               js[indx] = x

          elements = js.get(0)
          for element in elements:
               args(element['color'])
               begin_time = time()
               self.__cur.execute(self.__ins_js_query,args)
               self.__conn.commit()
               end_time = time()
               self.__timeSum['timeInsert'] += (end_time - begin_time)

     def clearTable(self):
          self.__cur.execute(self.__clr_tab)
          self.__conn.commit()

     def extractAllImages(self):
          try:
               import io
               from io import BytesIO
               import PIL
               from PIL import Image

               begin_time = time()
               self.__cur.execute(self.__extract_all)
               end_time = time()
               self.__timeSum['timeExtract'] += (end_time - begin_time)
               res = self.__cur.fetchall()
               for x in res:
                    data = BytesIO(x[0])
                    img = Image.open(data)
                    path_file = self.__path_target + '\\' + x[1]
                    img.save(path_file)
          except:
               self.disconnectDB()
               return(4)
          return(True)

     def getTime(self):
          return(self.__timeSum)

     def __importPostgre(self):
          import psycopg2
          return (psycopg2)