import getpass
import os
import re
import basic.toolHandling
import tools.data_const as D
import basic.constants as B
import tools.date_tool
import tools.file_tool

ENTITY_NAME = "name"
ENTITY_ATTRIBUTES = "attributes"
ENTITY_INS_COMMIT = "inscommit"
ENTITY_INS_AUTHOR = "insauthor"
ENTITY_INS_TIME = "instime"
ENTITY_UPD_COMMIT = "updcommit"
ENTITY_UPD_AUTHOR = "updauthor"
ENTITY_UPD_TIME = "updtime"
ENTITY_ACTUAL = "actual"
VAL_ACTUAL = 1
VAL_ZERO_TIME = "2000-01-01_00-00-00"
ENTITY_FIELDS = [ENTITY_INS_COMMIT, ENTITY_INS_AUTHOR, ENTITY_INS_TIME,
                 ENTITY_UPD_COMMIT, ENTITY_UPD_AUTHOR, ENTITY_UPD_TIME, ENTITY_ACTUAL]
SYNC_FULL_GIT2DB = "full-git-db"
SYNC_HEAD_GIT2DB = "head-git-db"
SYNC_COPY_FILE2DB = "copy-file-db"
SYNC_ONLY_GIT = "only-git"
SYNC_ONLY_DB = "only-db"
LIST_ENTITY_SYNC = [SYNC_ONLY_GIT, SYNC_FULL_GIT2DB, SYNC_HEAD_GIT2DB, SYNC_COPY_FILE2DB, SYNC_ONLY_DB]


def getEntityValue(job, field, gitcommit):
    if field == ENTITY_INS_COMMIT:
        return ""
    if field == ENTITY_INS_AUTHOR:
        return getpass.getuser()
    if field == ENTITY_INS_TIME:
        return tools.date_tool.getActdate(tools.date_tool.F_DIR)
    if field == ENTITY_UPD_COMMIT:
        return gitcommit["commit"]
    if field == ENTITY_UPD_AUTHOR:
        return gitcommit["author"]
    if field == ENTITY_UPD_TIME:
        return gitcommit["date"]
    if field == ENTITY_ACTUAL:
        return VAL_ACTUAL


class Entity:
    def __int__(self, job):
        self.job = job
        self.table = ""
        self.testserver = None

    def get_schema(self):
        """
        gets schema/ddl-informations in order to create the database
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def read_entity(self, job, name):
        """
        reads the entity from the file-system
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def select_entity(self, job, name):
        """
        reads the entity from the database
        it should get the same result like read_entity
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def write_entity(self, job, name):
        """
        writes the entity into the database
        it similar to update_entity
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def update_entity(self, job, name):
        """
        writes the entity into the database
        it similar to update_entity
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def remove_entity(self, job, name):
        """
        removes the entity from the file-system
        it similar to delete_entity
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def delete_entity(self, job, name):
        """
        deletes the entity into the database
        it similar to update_entity
        :param job:
        :param name:
        :return:
        """
        raise Exception(B.EXCEPT_NOT_IMPLEMENT)

    def getDbAttr(self, job):
        out = {}
        for attr in [B.ATTR_DB_HOST, B.ATTR_DB_USER, B.ATTR_DB_DATABASE, B.ATTR_DB_PASSWD]:
            out[attr] = job.conf[B.TOPIC_NODE_DB][attr]
        return out

    def getDdl(self, job, ddl):
        out = {}
        for t in ddl:
            out[t] = {}
            for f in ddl[t]:
                out[t][f] = {}
                for a in ddl[t][f]:
                    print("entity-23 "+f+", "+a+" "+str(ddl))
                    out[t][f][a] = ddl[t][f][a]
                out[t][f][D.DDL_FNAME] = f
            out[t][B.DATA_NODE_HEADER] = list(ddl[t].keys())
        return out

    def createSchema(self, testserver):
        if B.TOPIC_NODE_DB in self.job.conf:
            dbi = basic.toolHandling.getDbTool(self.job, testserver, self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE])
        else:
            return "No DB in job-config"
        sql = self.get_schema()
        print(sql)
        for s in sql.split(";\n"):
            if len(s) < 3: continue
            try:
                dbi.execStatement(s+";", self.job.conf[B.TOPIC_NODE_DB])
                print("SQL executed: "+s)
            except Exception as e:
                raise Exception("Fehler bei createSchema "+s)




    def getHistoryFields(self):
        dbtype = self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]
        dbi = basic.toolHandling.getDbTool(self.job, None, dbtype)
        sql = dbi.getSchemaAttribut("inscommit", D.TYPE_STR)+","
        sql += dbi.getSchemaAttribut("insauthor", D.TYPE_STR)+","
        sql += dbi.getSchemaAttribut("instime", D.TYPE_TIME)+","
        sql += dbi.getSchemaAttribut("updcommit", D.TYPE_STR)+","
        sql += dbi.getSchemaAttribut("updauthor", D.TYPE_STR)+","
        sql += dbi.getSchemaAttribut("updtime", D.TYPE_TIME)+","
        sql += dbi.getSchemaAttribut("actual", D.TYPE_INT)
        return sql

    def selectHistoryFields(self):
        if B.TOPIC_NODE_DB in self.job.conf:
            dbi = basic.toolHandling.getDbTool(self.job, self.testserver, self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE])
        else:
            return "No DB in job-config"
        dbi.selectRows

    def getHistoryIndex(self, table):
        dbtype = self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]
        dbi = basic.toolHandling.getDbTool(self.job, None, dbtype)
        sql = dbi.getSchemaIndex(table, "actual") + "\n"
        return sql


def read_spec(job, testentity, testgran, specpath):
    if not os.path.isfile(specpath):
        return
    text = tools.file_tool.read_file_text(job, specpath, job.m)
    if re.match(r".*?depricated;[jJyY]", text):
        return None
    spec = {}
    regex = re.compile(r".*\nhead:(.*?);(.+)")
    for res in regex.finditer(text):
        #res = re.search(r".*head:(.*?);(.+)\n", text)
        key = res.group(1)
        if key == B.SUBJECT_DESCRIPTION:
            spec[B.SUBJECT_DESCRIPTION] = res.group(2).replace(";", "")
        elif key in [B.SUBJECT_APPS, B.PAR_APP]:
            apps = res.group(2).replace(";", ",").split(",")
            spec[B.SUBJECT_APPS] = apps
        else:
            val = res.group(2).replace(";", "")
            spec[key] = val
    return spec