#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
#Nom :  : insert_zh.py
#Description : Insertion de nouveaux sites et mise à jour des anciens.
#Copyright : 2021, CEN38
#Auteur    : Colas Geier
#Version : 1.0

from binascii import Error, Incomplete
import pandas as pd
import geopandas as gpd
from pyproj import crs
import pycen
con = pycen.con


def crsp_colSite(df):
  '''
  Dictionnaire pour la table sites.sites 
  de correspondance des colonnes :
    id, nom, remarques, date_deb.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    **dict.fromkeys(['site_cod','site_code','CODE_SITE'], 'id'),
    'site_name': 'nom',
    'zh_remarks': 'remarques',
    'editdate': 'date_deb',
  })

def crsp_colGeomSite(df):
  '''
  Dictionnaire pour la table sites.r_sites_geom 
  de correspondance des colonnes :
    id_site, date, link_pdf, geom, rmq_fct_majeur,
    rmq_interet_patri, rmq_bilan_menace, rmq_orient_act, 
    rmq_usage_process.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    'site_code': 'id_site',
    'site_cod': 'id_site',
    'date_modif': 'date',
    'www': 'link_pdf',
    'geometry': 'geom',
    'fct_valeurs_majeurs': 'rmq_fct_majeur',
    'int_patr_majeur': 'rmq_interet_patri',
    'bilan_menaces_facteurs': 'rmq_bilan_menace',
    'orient_actions': 'rmq_orient_act',
    'usages_process': 'rmq_usage_process',
  })

def crsp_colSiteHab(df):
  '''
  Dictionnaire pour la table zones_humides.r_site_habitat 
  de correspondance des colonnes :
    id_site, date, id_cb.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    'site_code': 'id_site',
    'site_cod': 'id_site',
    'date_modif': 'date',
    'cb_cod': 'id_cb',
    'code_cb': 'id_cb',
  })

def crsp_colSiteUsgPrss(df):
  '''
  Dictionnaire pour la table zones_humides.r_site_usageprocess 
  de correspondance des colonnes :
    id_site, date, remarques.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    'site_code': 'id_site',
    'site_cod': 'id_site',
    'date_modif': 'date',
    'remarks': 'remarques',
  })

def crsp_colSiteRegHydro(df):
  '''
  Dictionnaire pour la table zones_humides.r_site_reghydro 
  de correspondance des colonnes :
    id_site, date, in, out, perm, rmq_toponymie.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    'site_code': 'id_site',
    'site_cod': 'id_site',
    'site_cod.1': 'id_site',
    'site_cod.2': 'id_site',
    'date_modif': 'date',
    'entree_eau': 'in',
    'sortie_eau': 'out',
    'perm_in': 'perm',
    'perm_out': 'perm',
    'topoinfl': 'rmq_toponymie',
    'topooutfl': 'rmq_toponymie',
  })

def crsp_colSiteFct(df):
  '''
  Dictionnaire pour la table zones_humides.r_site_fctecosociopatri 
  de correspondance des colonnes :
    id_site, date, remarques.
  '''
  df.columns = df.columns.str.lower()
  return df.rename(columns={
    'site_code': 'id_site',
    'site_cod': 'id_site',
    'date_modif': 'date',
    'memo': 'description',
  })

def crsp_idUsgPrss(df,table_param,id_col,nom_col,description=False):
  '''
  Réalise la correspondance entre les usages 
  ou les processus naturels et leur identifiants respectifs.
  '''
  df  = df.copy()
  df[nom_col] = df[nom_col].str[0].str.upper() + df[nom_col].str[1:]
  # df[nom_col] = df[nom_col].str.capitalize()
  ids = pycen.zh()._get_param(param_table=table_param)
  if description:
    df[nom_col] = df[nom_col].replace([*ids.description], [*ids.nom])
  df[id_col] = df[nom_col].replace([*ids.nom], [*ids.id])
  # df[id_col] = df[nom_col].replace([*ids.nom.str.capitalize()], [*ids.id])
  result = any(elem in [*df[id_col].unique()] for elem in [*ids.id])
  if not result:
    df[nom_col] = df[nom_col].str[0].str.upper() + df[nom_col].str[1:].str.lower()
    df[id_col] = df[nom_col].replace([*ids.nom], [*ids.id])

  return df


def get_id_auteur(lst_autor):
  '''
  Récupération des identifiants auteurs en 
  fonction de la liste des auteurs fournis.
  '''
  sch = 'personnes'
  tab = 'personne'
  sql = """    
    WITH tmp as 
      (SELECT id, TRIM(CONCAT(UPPER(nom),' ',prenom)) as auteur FROM {sch}.{tab}
	  UNION ALL
	  SELECT id, TRIM(CONCAT(nom,' ',prenom)) as auteur FROM {sch}.{tab}),
    tmp2 as 
      (SELECT 
      	p.id, TRIM(UPPER(p.nom)||' '||p.prenom||' '||CONCAT('(',o."abbrev",')')) as auteur 
      FROM {sch}.{tab} p join {sch}.organisme o on p.id_organisme=o.id),
    tmp3 as 
      (SELECT 
      	p.id, TRIM(UPPER(p.nom)||' '||p.prenom||' '||CONCAT('(',o.nom,')')) as auteur 
      FROM {sch}.{tab} p join {sch}.organisme o on p.id_organisme=o.id),
     tmp4 as (
    SELECT * FROM tmp 
    UNION ALL
    SELECT * FROM tmp2
    UNION ALL
    SELECT * FROM tmp3
     )
    SELECT DISTINCT * FROM tmp4
    WHERE auteur {symb} %(lst_autor)s
    ORDER BY 1;""".format(
      sch=sch,
      tab=tab,
      symb='IN' if len(lst_autor) > 1 else '=')
  df = pd.read_sql(
    sql = sql,
    con = con,
    params = {'lst_autor': tuple(lst_autor) })
  return df


def forme_typsite(df):
  '''
  Conversion des types de sites en identifiants
  pour insertion en BDD.
  '''
  df = df.copy()
  typsite = pycen.sites._get_typ_site()
  if 'type_site' in df.columns :
    print('   A CODER !!!!')
    df['id_type_site'] = df.type_milieux.replace([*typsite.nom], [*typsite.id])
    df.drop(columns=['type_site'], inplace=True)
  else:
    df['id_type_site'] = typsite.loc[typsite.nom == 'N.D.', 'id'].values[0]
  return df


def forme_typsdage(df):
  '''
  Conversion des types de sites en identifiants
  pour insertion en BDD.
  '''
  df = df.copy()
  typsdage = pycen.sites._get_typo_sdage()
  if 'typo_sdage' in df.columns :
    df['id_typo_sdage'] = df.typo_sdage.replace([*typsdage.nom], [*typsdage.id])
    df.drop(columns=['typo_sdage'], inplace=True)
  else:
    df['id_type_milieu'] = typsdage.loc[typsdage.nom == 'Inconnu', 'id'].values[0]
  return df


def forme_typmilieu(df):
  '''
  Conversion des types de milieux en identifiants
  pour insertion en BDD.
  '''
  df = df.copy()
  typmilieux = pycen.sites._get_typ_milieux()
  if 'type_milieux' in df.columns :
    df['id_type_milieu'] = df.type_milieux.replace([*typmilieux.nom], [*typmilieux.id])
    df.drop(columns=['type_milieux'], inplace=True)
  else:
    df['id_type_milieux'] = typmilieux.loc[typmilieux.nom == 'N.D.', 'id'].values[0]
  return df


def drop_maxDateGeomData(shP):
  '''
  Récupération des attributs antérieurs 
  à la géométries la plus actuelle. 
  Fonction créée dans le cas où la géométrie
  la plus actuelle ne possède pas encore d'attributs.
  '''
  df = shP.copy()
  keys = [*df.keys()]
  for k in keys:
    if k != 'infos' and isinstance(df[k], pd.DataFrame):
      # date_col = [col for col in df[k].columns if 'date' in col]
      if 'date_geom' in df[k].columns:
        date_col = 'date_geom'
      elif 'date' in df[k].columns:
        date_col = 'date'
      df[k] = df[k].sort_values(date_col)
      m = df[k][date_col].max()
      index = df[k][df[k][date_col]==m].index
      df[k] = df[k].drop(labels = index)
    elif k != 'infos' and isinstance(df[k], dict):
      kkeys = [*df[k].keys()]
      if 'title' in kkeys:
        kkeys.remove('title')
      for kk in kkeys:
        date_col = 'date_geom'
        if len(df[k][kk][date_col].unique()) > 1:
          df[k][kk] = df[k][kk].sort_values(date_col)
          m = df[k][kk][date_col].max()
          index = df[k][kk][df[k][kk][date_col]==m].index
          df[k][kk] = df[k][kk].drop(labels = index)

  return df


def insert_autorSiteData(df):
  '''
  Insertion des auteurs des sites.
  '''
  df = df.copy()
  df = df[['id', 'auteur']].copy()
  if df.auteur.str.contains(',|&').any():
    df = (df
      .set_index('id',drop=True)
      .auteur.str.split(',|&')
      .explode()
      .str.strip()
      .reset_index(drop=False))
  df_autor = get_id_auteur([*df.auteur.unique()])
  df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
  df.columns = ['id_site','id_auteur']
  df.to_sql(
    name='r_sites_auteur',
    con=con,
    schema='sites',
    index=False,
    if_exists='append',
    method='multi'
  )
  return 'Insert author sites data OK !'


def insert_autorGeomData(df):
  '''
  Insertion des auteurs des geometries.
  '''
  df = df.copy()
  df = df[['id', 'auteur']].copy()
  if df.auteur.str.contains(',|&').any():
    df = (df
      .set_index('id',drop=True)
      .auteur.str.split(',|&')
      .explode()
      .str.strip()
      .reset_index(drop=False))
  df_autor = get_id_auteur([*df.auteur.unique()])
  df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
  df.columns = ['id_geom_site','id_auteur']
  try : 
    df.to_sql(
      name='r_geomsites_auteur',
      con=con,
      schema='sites',
      index=False,
      if_exists='append',
      method='multi'
    )
  except Exception as e:
    print('ERROR : News author sites insert impossible !')
    print(e)
  return 'Insert author sites data OK !'


def name_site(df):
  '''
  Définition du code_site du site.
  '''
  df['id'] = df.index
  srd = (pycen.ref.territoire.sdr_ressources_en_eau()
        .drop(columns=['superficie','perimetre']))
  dep = pycen.ref.territoire.dept_isere()
  if 'dept' not in df.columns:
    isindep = df.intersects(dep.unary_union)
    df.loc[isindep,'dept'] = '38'
  if df.dept.isna().any():
    notindept = df[df.dept.isna()].index.tolist()
    raise('ERROR : Certaines zones humides ne sont pas dans le département :\n %s'%str(notindept))
  
  df['surf'] = df.area
  tmp = gpd.overlay(srd,df,how='intersection',make_valid=True,keep_geom_type=False)
  tmp['perc_rcvmt'] = 100*tmp.area/tmp['surf']
  tmp.sort_values(['id','perc_rcvmt'],inplace=True)
  test = tmp.id.duplicated(keep='first')
  tmp = tmp[test]
  df = (df.merge(tmp[['id','code_tr']],how='left',on='id')
        .rename(columns={'code_tr':'org'}))

  for s in srd.iterrows():
    org = s[1].code_tr
    num = con.execute("SELECT max(num::int) FROM sites.sites WHERE org = '%s'"%org).one()[0]
    test = df.org == org
    dim = df[test].shape[0]
    df.loc[test, 'num'] = list(range(num,num+dim))
  
  df.loc[df.num.str.len() == 1,'num'] = '000'+ df.loc[df.num.str.len() == 1,'num']
  df.loc[df.num.str.len() == 2,'num'] = '00' + df.loc[df.num.str.len() == 2,'num']
  df.loc[df.num.str.len() == 3,'num'] = '0'  + df.loc[df.num.str.len() == 3,'num']

  df['id'] = df.dept + df.org + df.num
  return df


def insertNewSite(df):
  '''
  Insertion des nouveaux sites.

  columns :
  ---------
  'site_cod', 'dept', 'org', 'num', 'site_name', 'editdate', 
  'auteur', 'organisat', 'maj', 'type_milieux'
  '''
  df = df.copy()

  columns = ['id', 'nom', 'date_deb', 'old_site', 'dept', 'org',
      'num', 'remarques', 'auteur', 'type_site', 'typo_sdage', 'type_milieux']
  df = crsp_colSite(df)
  if 'id' not in df.columns:
    df = name_site(df)
  c = df.columns[df.columns.isin(columns)]
  df['date_deb'] = pd.to_datetime(df['date_deb'])
  df = df[c]
  df = forme_typsite(df)
  df = forme_typmilieu(df)
  df = forme_typsdage(df)
  c = df.columns
  try:
    df[c.drop('auteur')].to_sql(
      name='sites',
      con=con,
      schema='sites',
      index=False,
      if_exists='append',
      method='multi'
    )
    try : 
      insert_autorSiteData(df)
    except Exception as e:
      print('ERROR : News author sites insert impossible !')
      print(e)
  except Exception as e : 
    print('ERROR : News sites insert impossible !')
    print(e)


def insertNewGeom(gdf, rmq_geom=pd.DataFrame()):
  '''
  Insertion des nouvelles géométries des sites
  et les éventuelles remarques associées.

  paramètres :
  ---------
  gdf : GeoDataFrame. Tableau des géométries 
    identifiées par leur code site respectifs.
  rmq_geom : DataFrame. Tableau des remarques 
    globales du sites pour ces géométries:
      'fct_valeurs_majeurs', 'int_patr_majeur',
      'bilan_menaces_facteurs', 'orient_actions'
  '''
  df = gdf.copy()
  columns = [ x['name'] for x in pycen.sites.columns_geomtab ] + ['auteur']
  df = crsp_colGeomSite(df)

  if df.crs.srs.split(':')[-1] != '2154':
    df.to_crs(2154,inplace=True)

  if not rmq_geom.empty :
    rmq_geom.columns = rmq_geom.columns.str.lower()
    rmq_geom = crsp_colGeomSite(rmq_geom)
    if 'date' in df.columns and 'date' in rmq_geom.columns:
      del rmq_geom['date']
    if 'auteur' in df.columns and 'auteur' in rmq_geom.columns:
      del rmq_geom['auteur']
    df = df.merge(rmq_geom, on='id_site', how='left')

  c = df.columns[df.columns.isin(columns)]
  df = df[c]
  df = pycen.tools.Polygons_to_MultiPolygon(df)
  try:
    df[c.drop('auteur')].to_postgis(
      name='r_sites_geom',
      con=con,
      schema='sites',
      #geom_col='geom',
      index=False,
      if_exists='append',
    )
  except Exception as e : 
    print('ERROR : News sites insert impossible !')
    print(e)

  sql = 'SELECT id, id_site, date FROM sites.r_sites_geom WHERE id_site IN %(id_site)s AND date IN %(date)s ;'
  tmp = pd.read_sql(sql=sql, con=con, params= {
    'id_site': tuple(df.id_site),
    'date': tuple(df.date)
  })
  tmp['date'] = tmp['date'].astype(str)
  df['date'] = df['date'].astype(str)
  df = df.merge(tmp, on=['id_site', 'date'], how='left')
  try : 
    insert_autorGeomData(df)
  except Exception as e:
    print('ERROR : News author sites insert impossible !')
    print(e)


def get_idGeomSite(lst_site):
  '''
  Récupération des identifiants des géometries
  des sites les plus récentes.
  '''
  id_geom = pycen.zh().get_sitesGeom(
    id_site=[*lst_site], last_update=True)
  id_geom = id_geom[['id','id_site']]
  id_geom.columns = ['id_geom_site','id_site']
  return id_geom


def select_ID(df,sch,tab):
  '''
  Récupération des identifiants des nouvelles 
  lignes insérées.

  paramètres :
  ---------
  df : pd.DataFrame, Tableau des données 
    attributaires insérées.
  sch : str. Nom du schéma où sont stockés les attributs.
  tab : str. Nom de la table.
  '''
  sql = 'SELECT * FROM %s.%s'%(sch,tab)
  df = df.copy().dropna(axis=1)
  if 'date' in df.columns:
    df['date'] = df['date'].astype(str)
  if 'id_cb' in df.columns:
    df['id_cb'] = df['id_cb'].astype(str)
  column = '(%s)'%','.join(df.columns)
  df_tuple = tuple(df.itertuples(index=False, name=None))
  sql = sql + ' WHERE %s IN %s'%(column,df_tuple)
  if 'nan' in sql: sql = sql.replace('nan','NULL')
  if '),)' in sql: sql = sql.replace('),)','))')
  if '"' in sql: sql = sql.replace('"',"'")

  # print(sql)
  return pd.read_sql(
    sql=sql,
    con=con,)


def insertAttrs(sh2, sch, tab):
  '''
  Insertion des nouveaux attributs des sites.
  Ne Concerne pas les auteurs des attributs 
  (cf. insertAutorAttrs).

  paramètres :
  ---------
  df : pd.DataFrame, Tableau des données 
    attributaires insérées.
  sch : str. Nom du schéma où sont stockés les attributs.
  tab : str. Nom de la table.
  '''
  df = sh2.copy()
  df = df.merge(get_idGeomSite(df.id_site), on=['id_site'], how='left')
  df.dropna(subset=['id_geom_site'],inplace=True)
  df['id_geom_site'] = df['id_geom_site'].astype(int)
  tab_cols = pycen.con.dialect.get_columns(con,schema=sch,table_name=tab)
  columns = [ x['name'] for x in tab_cols ] + ['auteur']
  c = df.columns[df.columns.isin(columns)]
  df['date'] = pd.to_datetime(df['date'])
  df = df[c]
  if tab == 'r_site_sub':
    df.dropna(subset=['id_freqsub'],inplace=True)
  try:
    df[c.drop('auteur')].to_sql(
      name=tab,
      con=con,
      schema=sch,
      index=False,
      if_exists='append',
      method='multi'
    )
    print('Insert attrs sites data OK !')
    return [df,True]
  except Exception as e : 
    print('ERROR : News sites insert impossible !')
    print(e)
    return [df,False]


def insertAutorAttrs(df,colname_rsite, sch, tab):
  '''
  Insertion des auteurs des attributs.

  paramètres :
  ---------
  df : pd.DataFrame, Tableau des données 
    attributaires insérées.
  colname_rsite : str. Nom du champs 
    relationnelle de la table auteur,
    se rapportant à la table attributaire.
  sch : str. Nom du schéma où se situe la table auteur.
  tab : str. Nom de la table auteur.
  '''
  df = df.copy()
  df = df[['id', 'auteur']].copy()
  df.drop_duplicates(inplace=True)
  if df.auteur.str.contains(',|&').any():
    df = (df
      .set_index('id',drop=True)
      .auteur.str.split(',|&')
      .explode()
      .str.strip()
      .reset_index(drop=False))
  # tmp = df.auteur.str.split(' & ', expand =True).stack().droplevel(-1)
  # df = pd.concat([df,tmp],axis=1)
  # del df['auteur']
  # df.columns = ['id', 'auteur']
  df_autor = get_id_auteur([*df.auteur.unique()])
  df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
  df.columns = [colname_rsite, 'id_auteur']
  try : 
    df.to_sql(
      name=tab,
      con=con,
      schema=sch,
      index=False,
      if_exists='append',
      method='multi'
    )
    print('Insert author sites data OK !')
    return 'Insert author sites data OK !'
  except Exception as e:
    print('ERROR : News author sites insert impossible !')
    print(e)


def insertAttrsCB(sh3):
  '''
  Insertion des nouvelles version des attributs
  habitats des sites zones humides.
  Affectation des attributs à la géométrie la plus récente.

  columns :
  ---------
  'site_cod', 'cb_cod', 'desc_cbiotope', 'auteur', 'date'
  '''
  tab = 'r_site_habitat'
  sch = pycen.zh().schema
  df = sh3.copy()
  df = crsp_colSiteHab(df)

  if df.id_cb.dtype == float:
    df.id_cb = df.id_cb.astype(str)
    df.id_cb = df.id_cb.replace('.0','',regex=True)
  df,ins = insertAttrs(df,sch, tab)

  if ins:
    ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
    same_col = df.columns[df.columns.isin(ids.columns)]
    if 'date' in same_col:
      df['date'] = df['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    df = df.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(df,colname_rsite='id_sitehab', sch=sch, tab='r_rsitehab_auteur')


def insertAttrsDelim(sh3):
  '''
  Insertion des nouvelles version des attributs
  de délimitation et de definition de l'espace de 
  fonctionnalité des sites zones humides.
  Affectation des attributs à la géométrie la plus récente.

  columns :
  ---------
  'site_cod', 'crit_def_esp', 'crit_delim', 'auteur', 'date'
  '''
  tab = 'r_site_critdelim'
  sch = pycen.zh().schema
  df = sh3.copy()
  inds = df.columns[~df.columns.isin(['crit_def_esp','crit_delim'])]
  df.set_index([*inds],inplace=True)
  df = df.stack().reset_index(-1)
  df.columns = ['type', 'nom']
  df.reset_index(inplace=True)
  df.drop_duplicates(inplace=True)

  param = pycen.zh()._get_param(param_table='param_delim_fct', type_table='type_param_delim_fct')
  for typ in df.type.unique():
    param_tmp = param.loc[param.type==typ]
    df.loc[df.type == typ,'id_crit_delim'] = df.loc[df.type == typ,'nom'].replace([*param_tmp.nom],[*param_tmp.id])
  df['id_crit_delim'] = df['id_crit_delim'].astype(int)
  df = crsp_colSiteHab(df)
  df,ins = insertAttrs(df,sch, tab)

  if ins:
    ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
    same_col = df.columns[df.columns.isin(ids.columns)]
    if 'date' in same_col:
      df['date'] = df['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    df = df.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(df,colname_rsite='id_sitedelim', sch=sch, tab='r_rsitedelim_auteur')


def insertAttrsUsgPrss(sh4):
  '''
  Insertion des nouvelles version des attributs
  usages et processus naturels des sites zones humides.
  Affectation des attributs à la géométrie la plus récente.

  columns :
  ---------
  'site_cod', 'remarks', 'activ_hum_autre', 'temp', 'affich_act',
  'localisation', 'activite_hum', 'typo_sdage', 'impact', 
  'auteur','date'
  '''
  tab = 'r_site_usageprocess'
  sch = pycen.zh().schema
  df = sh4.copy()
  df = crsp_idUsgPrss(df,table_param='param_activ_hum',id_col='id_activ_hum', nom_col='activite_hum')
  df = crsp_idUsgPrss(df,table_param='param_impact',id_col='id_impact', nom_col='impact')
  if len(df.localisation.max()) > 10: descript = True
  else : descript = False
  df = crsp_idUsgPrss(
    df,table_param='param_position',id_col='id_position', 
    nom_col='localisation',description=descript)
  df = crsp_colSiteUsgPrss(df)
  df,ins = insertAttrs(df,sch, tab)

  if ins:
    ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
    same_col = df.columns[df.columns.isin(ids.columns)]
    if 'date' in same_col:
      df['date'] = df['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    for col in same_col:
      if df[col].dtype != ids[col].dtype:
        print(col)
        if df[col].dtype == float:
          ids[col] = ids[col].astype(float)
        elif df[col].dtype == object:
          ids[col] = ids[col].astype(object)
    df = df.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(df,colname_rsite='id_siteusage', sch=sch, tab='r_rsiteusage_auteur')


def insertAttrsRegHydro(sh5):
  '''
  Insertion des nouvelles version des attributs
  régimes hydriques des sites zones humides.
  Affectation des attributs à la géométrie la plus récente.

  columns :
  ---------
  'site_cod', 'topoinfl', 'entree_eau', 'perm_in', 'unnamed: 4',
  'unnamed: 5', 'unnamed: 6', 'site_cod.1', 'topooutfl', 'sortie_eau',
  'perm_out', 'unnamed: 11', 'unnamed: 12', 'unnamed: 13', 'unnamed: 14',
  'site_cod.2', 'sub_orig', 'sub_freq', 'sub_etend', 'connexion',
  'auteur', 'date'
  '''
  dic = {
    'Canaux / fossés':'Canaux/fossés',
    'Nappe':'Nappes',
  }
  sch = pycen.zh().schema
  tab_regHyd = 'r_site_reghydro'
  tab_con = 'r_site_type_connect'
  tab_sub = 'r_site_sub'
  p_inout_perm = pycen.zh()._get_param(param_table='param_permanence')
  p_inout_rHyd = pycen.zh()._get_param(param_table='param_reg_hydro')
  p_con_sub = pycen.zh()._get_param(param_table='param_sub', type_table='type_param_sub',type_court=False)
  p_con_cnx = pycen.zh()._get_param(param_table='param_type_connect')

  df = sh5.copy()
  df.set_index(['auteur', 'date'],inplace=True)
  dfin  = df.iloc[:,:4].copy()
  dfout = df.iloc[:,7:11].copy()
  dfcon = df.iloc[:,15:].copy()
  dfin  = crsp_colSiteRegHydro(dfin).set_index('id_site',append=True)
  dfout = crsp_colSiteRegHydro(dfout).set_index('id_site',append=True)
  dfcon = crsp_colSiteRegHydro(dfcon).set_index('id_site',append=True)
  dfin = dfin.dropna(how='all').reset_index(drop=False)
  dfout = dfout.dropna(how='all').reset_index(drop=False)
  dfcon = dfcon.dropna(how='all').reset_index(drop=False)

  col_inout = ['in','out']
  dfinout = pd.concat([dfin,dfout])
  dfinout.set_index([*dfinout.columns[~dfinout.columns.isin(col_inout)]], inplace=True)
  dfinout = dfinout.stack().reset_index(-1, drop=False)
  dfinout.columns = ['in_out','reg_hydro']
  dfinout.reset_index(inplace=True, drop=False)
  dfinout['reg_hydro'] = dfinout['reg_hydro'].str[0].str.upper() + dfinout['reg_hydro'].str[1:]
  dfinout['reg_hydro'].replace(dic, inplace=True)
  dfinout.in_out.replace(['in','out'],[True,False],inplace=True)
  dfinout['id_reg_hydro'] = dfinout['reg_hydro'].str.lower() \
    .replace([*p_inout_rHyd.nom.str.lower()],[*p_inout_rHyd.id])
  dfinout['id_permanance'] = dfinout['perm'].str.lower() \
    .replace([*p_inout_perm.nom.str.lower()],[*p_inout_perm.id.astype(str)])

  if dfcon.columns.str.contains('sub').any():
    if dfcon['sub_freq'].dtype != object:
      dfcon['sub_freq'] = dfcon['sub_freq'].astype(object)
    if dfcon['sub_etend'].dtype != object:
      dfcon['sub_etend'] = dfcon['sub_etend'].astype(object)
    dfcon['sub_freq'].fillna('Inconnu',inplace=True)
    dfcon['sub_etend'].fillna('Inconnu',inplace=True)
    dfcon['id_freqsub'] = dfcon['sub_freq'].str.lower() \
      .replace([*p_con_sub.nom.str.lower()],[*p_con_sub.id.astype(str)])
    dfcon['id_etendsub'] = dfcon['sub_etend'].str.lower() \
      .replace([*p_con_sub.nom.str.lower()],[*p_con_sub.id.astype(str)])
    dfcon['id_origsub'] = dfcon['sub_orig']
  else :
    dfcon['id_freqsub'] = p_con_sub[
      (p_con_sub.type == 'Submersion fréquente') & 
      (p_con_sub.nom == 'Inconnu')].id.values[0]
  dfcon['id_param_connect'] = dfcon['connexion'].str.lower() \
    .replace([*p_con_cnx.nom.str.lower()],[*p_con_cnx.id.astype(str)])
  
  dfinout,ins = insertAttrs(dfinout,sch, tab_regHyd)
  if ins:
    ids = select_ID(dfinout[dfinout.columns.drop('auteur')],sch,tab_regHyd)
    same_col = dfinout.columns[dfinout.columns.isin(ids.columns)]
    if 'date' in same_col:
      dfinout['date'] = dfinout['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    for c in same_col:
      if dfinout[c].dtype != ids[c].dtype:
        dfinout[c] = dfinout[c].astype(ids[c].dtype)
    dfinout = dfinout.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(dfinout,colname_rsite='id_sitehydro', sch=sch, tab='r_rsitehydro_auteur')
  else: return

  dfconn = dfcon.copy()
  dfcon,ins = insertAttrs(dfcon,sch, tab_sub)
  if ins:
    ids = select_ID(dfcon[dfcon.columns.drop('auteur')],sch,tab_sub)
    ids.loc[~ids.id_etendsub.isna(),'id_etendsub'] = ids.loc[~ids.id_etendsub.isna(),'id_etendsub']\
      .astype(int)
    if ids.id_freqsub.dtype==int:
      ids.id_freqsub = ids.id_freqsub.astype(str)
    same_col = dfcon.columns[dfcon.columns.isin(ids.columns)]
    if 'date' in same_col:
      dfcon['date'] = dfcon['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    for col in same_col:
      if dfcon[col].dtype != ids[col].dtype:
        print(col)
        if dfcon[col].dtype == float:
          ids[col] = ids[col].astype(float)
        elif dfcon[col].dtype == int:
          ids[col] = ids[col].astype(int)
        elif dfcon[col].dtype == object:
          ids[col] = ids[col].astype(object)
    dfcon = dfcon.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(dfcon,colname_rsite='id_sitesub', sch=sch, tab='r_rsitesub_auteur')
  else: return
  
  dfconn,ins = insertAttrs(dfconn,sch, tab_con)
  if ins:
    ids = select_ID(dfconn[dfconn.columns.drop('auteur')],sch,tab_con)
    if ids.id_param_connect.dtype==int:
      ids.id_param_connect = ids.id_param_connect.astype(str)
    same_col = dfconn.columns[dfconn.columns.isin(ids.columns)]
    if 'date' in same_col:
      dfconn['date'] = dfconn['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    dfconn = dfconn.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(dfconn,colname_rsite='id_siteconnect', sch=sch, tab='r_rsiteconnect_auteur')
  else: return


def insertAttrsFct(sh6,nom_typ_court=False):
  '''
  Insertion des nouvelles version des attributs
  fonctions biologiques, écologiques, sociologiques, 
  patrimoniale des sites zones humides.
  Affectation des attributs à la géométrie la plus récente.

  columns :
  ---------
  'site_cod', 'fonction', 'typ_fonc', 'memo', 'auteur', 'date'
  '''
  tab = 'r_site_fctecosociopatri'
  sch = pycen.zh().schema
  df = sh6.copy()
  df = crsp_colSiteFct(df)
  param = pycen.zh()._get_param(
    param_table='param_fct_eco_socio_patri', 
    type_table='type_param_fct',type_court=nom_typ_court)

  for typ in df.typ_fonc.unique():
    param_tmp = param.loc[param.type==typ]
    df.loc[df.typ_fonc == typ,'id_fct'] = df.loc[df.typ_fonc == typ,'fonction'] \
      .str.lower() \
      .replace([*param_tmp.nom.str.lower()],[*param_tmp.id])
  df['id_fct'] = df['id_fct'].astype(int)
  
  df,ins = insertAttrs(df,sch, tab)
  if ins:
    ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
    if 'description' in df.columns:
      df.description = df.description.astype(str)
      df.loc[df.description=='nan','description'] = 'None'
      ids.description = ids.description.astype(str)
      if df.description.str.contains("'").any():
        df.description = df.description.replace("'","''",regex=True)
    if df.shape[0] != ids.shape[0]:
      ids = select_ID(df[df.columns.drop(['auteur','description'])],sch,tab)
    if 'description' in df.columns:
      if df.description.str.contains("''").any():
        df.description = df.description.replace("''","'",regex=True)
    same_col = (df.columns[df.columns.isin(ids.columns)])
    if 'date' in same_col:
      df['date'] = df['date'].astype(str)
      ids['date'] = ids['date'].astype(str)
    df = df.merge(ids, on=[*same_col], how='left')
    insertAutorAttrs(df,colname_rsite='id_sitefct', sch=sch, tab='r_rsitefct_auteur')


if __name__ == "__main__":

  from os import path
  FILE_PATH = '/home/colas/Documents/9_PROJETS/1_ZH/MAJ/Assistance GAM/actu_ZH'
  GEOM_PATH = 'contour_ZH.gpkg'
  DATA_PATH = 'Tableau_saisie_ZH.xlsx'

  Gdf = gpd.read_file(path.join(FILE_PATH,GEOM_PATH), crs='EPSG:2154')
  Gdf.columns = Gdf.columns.str.lower()
  Gdf.rename(columns={'code_site':'site_code'},inplace=True)

  # Gdf['site_code'] = '38GR0070'
  # lst = ['38BB0089','38BB0090','38BB0091','38BB0092']
  # gdf = gdf[gdf.site_code.isin(lst)]
  DF  = pd.read_excel(path.join(FILE_PATH,DATA_PATH), sheet_name=None, header=1)
  lst_sheet = [*DF.keys()]
  for k in lst_sheet:
    if isinstance(DF[k], pd.DataFrame):
      DF[k].columns = DF[k].columns.str.lower()
    elif isinstance(DF[k], dict):
      lst_tmp = [*DF[k].keys()]
      for kk in lst_tmp:
        if isinstance(DF[k][kk], pd.DataFrame):
          DF[k][kk].columns = DF[k][kk].columns.str.lower()

  sh1 = DF[lst_sheet[0]]
  sh1 = sh1[sh1.maj != 'SUPP'].copy()
  sh1.editdate = pd.to_datetime(sh1.editdate)

  sh1.auteur.replace(
    ['Nicolas BIRON','Alix GUEDOU'],
    ['BIRON Nicolas','GUEDOU Alix'],
    inplace=True)

  lst_site = list(sh1.site_cod.unique())
  gdf = Gdf[Gdf.site_code.isin(lst_site)].reset_index(drop=True)
  if gdf.geometry.name != 'geom':
    gdf.rename_geometry('geom', inplace=True)
  lst_site = list(gdf.site_code.unique())
  sh1 = sh1[sh1.site_cod.isin(lst_site)]
  sh1.name = lst_sheet[0]
  gdf['auteur'] = sh1.auteur.values[0]


  data_date = sh1[['site_cod','upddate']].copy()
  data_date.columns = ['site_cod', 'date'] 
  data_date.loc[data_date.date.isnull(),'date'] = sh1.loc[
    sh1.site_cod.isin(
      data_date.loc[data_date.date.isnull(),'site_cod']),
    'editdate']
  data_date['date'] = pd.to_datetime(data_date['date'])
  if 'date' not in gdf.columns:
    gdf = gdf.merge(data_date, left_on=['site_code'], right_on=['site_cod'], how='left')
    del gdf['site_cod']
    gdf['date_modif'] = gdf['date']
    del gdf['date']

  sh2 = DF[lst_sheet[1]]
  sh2['auteur'] = sh1.auteur.values[0]
  sh2 = sh2.merge(data_date, on=['site_cod'], how='left')
  sh2 = sh2[sh2.site_cod.isin(lst_site)]
  sh2.name = lst_sheet[1]
  sh3 = DF[lst_sheet[2]]
  sh3['auteur'] = sh1.auteur.values[0]
  sh3 = sh3[sh3.site_cod.isin(lst_site)]
  sh3.name = lst_sheet[2]
  sh3 = sh3.merge(data_date, on=['site_cod'], how='left')
  sh4 = DF[lst_sheet[3]]
  sh4['auteur'] = sh1.auteur.values[0]
  sh4 = sh4.merge(data_date, on=['site_cod'], how='left')
  sh4 = sh4[sh4.site_cod.isin(lst_site)]
  sh4.name = lst_sheet[3]
  sh5 = DF[lst_sheet[4]]
  sh5['auteur'] = sh1.auteur.values[0]
  if sh5.site_cod.isna().any():
    sh5.loc[sh5.site_cod.isna(),'site_cod'] = sh5.loc[sh5.site_cod.isna(),'site_cod.1']
  sh5 = sh5.merge(data_date, on=['site_cod'], how='left')
  sh5 = sh5[sh5.site_cod.isin(lst_site)]
  sh5.name = lst_sheet[4]
  sh6 = DF[lst_sheet[5]]
  sh6['auteur'] = sh1.auteur.values[0]
  sh6 = sh6.merge(data_date, on=['site_cod'], how='left')
  sh6 = sh6[sh6.site_cod.isin(lst_site)]
  sh6.name = lst_sheet[5]
  sh7 = DF[lst_sheet[6]]
  sh7['auteur'] = sh1.auteur.values[0]
  sh7 = sh7.merge(data_date, on=['site_cod'], how='left')
  sh7 = sh7[sh7.site_cod.isin(lst_site)]
  sh7.name = lst_sheet[6]
  sh8 = DF[lst_sheet[7]]
  sh8['auteur'] = sh1.auteur.values[0]
  sh8 = sh8.merge(data_date, on=['site_cod'], how='left')
  sh8 = sh8[sh8.site_cod.isin(lst_site)]
  sh8.name = lst_sheet[7]



  add = sh1[sh1.maj=='ADD'].copy()
  add = add.dropna(axis=1, how='any')
  add['type_milieux'] = 'Tourbières et marais'
  add = pd.merge(
    add,
    sh4[['site_cod','typo_sdage']].dropna(how='any').drop_duplicates(), 
    how='left',on='site_cod')
  # add = forme_typsdage(add)
  # maj = gdf[~gdf.site_code.isin(add.site_code)].copy()

  # tmp = pycen.get_sitesGeom(id_site=['38BB0052','38BB0050'])
  # gdf.loc[gdf.site_code=='38BB0050','geom'] = gdf[gdf.site_code=='38BB0050'].geom


  insertNewSite(add)
  insertNewGeom(gdf, rmq_geom=sh7)


  insertAttrsDelim(sh3)
  insertAttrsCB(sh2)
  insertAttrsUsgPrss(sh4)
  insertAttrsRegHydro(sh5)
  insertAttrsFct(sh6.dropna(axis=1,how='all'))


  maj = sh1[sh1.maj=='MAJ'].copy()
  lst_maj = [*maj.site_cod]
  # site = lst_maj[3]
  for site in lst_maj:
    print(site)
    shP = pycen.zh().get_bilan(code_site=site,last_update=False)
    shP = drop_maxDateGeomData(shP)
    sh2b = shP['corine_biotope'].copy()
    sh2b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
    del sh2b['id']
    sh3b = shP['delimitation'].copy()
    sh3b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
    sh3b = sh3b.set_index([ *sh3b.columns[~sh3b.columns.isin(['nom_crit'])] ])\
      .unstack(level=-4).droplevel(0,axis=1).reset_index(drop=False)
    del sh3b['id']
    sh4b = shP['description'].copy()
    sh4b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
    sh4b.rename(columns={'position':'localisation'},inplace=True)
    del sh4b['id']
    sh5b = shP['fonctionnement'].copy()
    sh5ba = sh5b['entree_eau'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
    sh5bb = sh5b['sortie_eau'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
    sh5bc = sh5b['sub_connex'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
    sh5ba = sh5ba[['site_cod','rmq_toponymie','regime_hydri','permanence']].rename(columns={'regime_hydri':'entree_eau','permanence':'perm_in'})
    sh5bb = sh5bb[['site_cod','rmq_toponymie','regime_hydri','permanence']].rename(columns={'regime_hydri':'sortie_eau','permanence':'perm_out'})
    sh5bc = sh5bc[['site_cod','connexion']]
    sh5ba[['unnamed: 4','unnamed: 5','unnamed: 6']] = None
    sh5bb[['unnamed: 11','unnamed: 12','unnamed: 13','unnamed: 14']] = None
    sh5B = pd.concat([sh5ba,sh5bb,sh5bc],axis=1)
    sh5B['date'] = sh1.loc[sh1.site_cod==site,'upddate'].values[0]
    sh5B['auteur'] = sh1.auteur.values[0]
    sh6b = shP['fonction'].copy()
    sh6b = sh6b.rename(columns={'type':'typ_fonc','nom_fct':'fonction'})
    sh6b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
    del sh6b['id']
    sh7b = shP['evaluation'].copy()
    sh7b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]


    insertAttrsCB(sh2b)
    insertAttrsDelim(sh3b)
    insertAttrsUsgPrss(sh4b)
    insertAttrsRegHydro(sh5B)
    insertAttrsFct(sh6b,nom_typ_court=True)

# st_clusterdbscan