#!/usr/bin/env python3
# -*- coding: UTF-8 -*-.

from sqlalchemy import create_engine #, text
from sqlalchemy.engine import URL
from shapely.geometry import Point
from shapely.ops import nearest_points
import pandas as pd
import geopandas as gpd


numerisateur = ['GEIER Colas']
lib_etude = 'Echange de données (partenaires)'
# précision possible : 
# GPS / 0 à 10m / 10 à 100m / 100 à 500m / commune / lieu-dit
precision_gps = 'GPS'


# Parametres bdd
user = 'cgeier'
pwd  = 'adm1n*bdCen'
adr  = '91.134.194.221'
port = '5432'
base = 'sicen2'

url = URL.create('postgresql+psycopg2', 
  username=user,
  password=pwd,
  host=adr,
  database=base,
)
con = create_engine(url)

dict_sp = {
    'Dilatata dilatata (Gould, 1841)':'Menetus dilatatus (A.A. Gould, 1841)',
    'Gomphocerippus biguttulus biguttulus (Linnaeus, 1758)':'Chorthippus biguttulus biguttulus (Linnaeus, 1758)',
    'Gomphocerippus mollis mollis (Charpentier, 1825)':'Chorthippus mollis mollis (Charpentier, 1825)',
}
dict_columns = {
    'TAXO_LATIN_C':'nom_latin',
    'RELV_NOM':'lot_donnees',
    'OBSE_DATE_J':'date_obs',
    'OBSE_LON':'longitude',
    'OBSE_LAT':'latitude',
    'SITE_NOM':'localisation',
    'OBSE_PLACE':'rmq_loc',
    'OBSV_LIBEL':'observateur',
    'DETM_LIBEL':'validateur',
    'OBSE_COMMENT':'remarque_obs',
    'OBSE_PCOLE_CHOI':'protocole',
    'OBSE_PRECIS_CHOI':'effectif_textuel',
    'OBSE_NOMBRE':'effectif',
    'OBSE_TIME':'heure_obs',
    'OBSE_COMP_CHOI':'reprostatut',
    'OBSE_CARACT_CHOI':'reprocaract',
    'OBSE_SIG_OBJ_ID':'id_origine',
    'OBSE_NEBUL_CHOI':'nebulosite',
    'OBSE_TPTAIR':'temperature',
    'OBSE_VENT_CHOI':'vent'
}
# dict_columns = {
#     'Nom scientifique':'nom_latin',
#     'CD_nom':'cd_nom',
#     'Observateur':'observateur',
#     'Date_Relevé':'date_obs',
#     'Code_Relevé':'id_waypoint',
#     'X lambert 93':'longitude',
#     'Y Lambert 93':'latitude',
#     'Altinf_Relevé':'elevation',
#     'Nom_LieuDit':'localisation',
#     'Description_Relevé':'remarque_obs',
#     'Statuts':'remarque_obsStatut',
#     'Lot_données':'lot_donnees',
#     'Localisation_Relevé':'rmq_loc'
# }



# sql = 'SELECT * FROM %s.%s LIMIT 10;' % ('saisie','saisie_observation')
# saisie = gpd.read_postgis(
#     sql = sql,
#     con = con,
#     geom_col = 'geometrie'
# )

def near(point,df2,geom_union,src_column):
     # find the nearest point and return the corresponding Place value
     geom2_col = df2.geometry.name
     nearest = df2[geom2_col] == nearest_points(point, geom_union)[1]
    #  print(nearest)
    #  print(df2[nearest][src_column])
     return df2[nearest][src_column].values[0]


def get_refGeomTable(table, schema,geom_col='geometrie',colnames=None,mask=None,buffer=None):
    '''
    Récupération de données géométriques dasn une table de référence
    '''
    pkey = con.dialect.get_pk_constraint(con,table,schema)['constrained_columns'][0]
    if colnames:
        colnames = [pkey,*colnames]
    else: 
        colnames = [pkey]
    cols = ','.join(colnames)
    sql = 'SELECT %s,%s FROM %s.%s' % (cols,geom_col,schema,table)
    if mask:
        if buffer : 
            mask = mask.buffer(buffer)
        sql = sql + """ WHERE ST_Intersects({geom_col}, 'SRID=2154;{mask}')""".format(
            geom_col=geom_col,
            mask=mask)
    gdf = gpd.read_postgis(
        sql,con,
        geom_col=geom_col)
    return gdf


def get_refTable(table, schema, colnames=None):
    pkey = con.dialect.get_pk_constraint(con,table,schema)['constrained_columns'][0]
    if colnames:
        colnames = [pkey,*colnames]
    else: 
        colnames = [pkey]

    sql = 'SELECT %s' % (','.join(colnames))
    sql = sql + ' FROM %s.%s' % (schema,table)
    df = pd.read_sql(sql,con)
    return df


def create_geometry(x,y):
    geom = [Point(xy) for xy in zip(x, y)]
    return geom


def normalize_obs(obs,name='first',sep=';'):
    '''
    :obs: pd.Series. Colonne des observateurs.
    :name: str. 'first' si le nom est cité en premier.
        'first',None. Défault 'first'.
    :sep: str. séparateur de personne dans le cas de 
        multi-observateur. Défault ';'.
    '''
    obs = obs.replace(sep,',',regex=True)
    obs = obs.replace(' ,',',',regex=True)
    obs = obs.replace(', ',',',regex=True)
    obs = obs.str.split(',',expand=True).stack()
    obs = obs.str.split(' ',expand=True)
    if name == 'first':
        obs[0] = obs[0].str.upper()
        obs[1] = obs[1].str[0].str.upper() + obs[1].str[1:]
        obs['pers'] = obs[0] + ' ' + obs[1]
    else:
        obs[1] = obs[1].str.upper()
        obs[0] = obs[0].str[0].str.upper() + obs[0].str[1:]
        obs['pers'] = obs[1] + ' ' + obs[0]
    obs = obs['pers'].unstack()
    obs['pers'] = obs[0]
    if 1 in obs.columns:
        obs.loc[~obs[1].isna(),'pers'] = obs.loc[~obs[1].isna(),'pers'] + '&' +\
            obs.loc[~obs[1].isna(),1]
    return obs['pers']
    

def get_pers(obs):
    '''
    :obs: pd.Series. Colonne des observateurs.
    '''
    obs = pd.Series(obs.unique())
    obs = obs.str.split(' ',expand=True)
    obs_name = "','".join(obs[0].str.upper().tolist())
    obs_surn = "','".join(obs[1].tolist())
    sql = '''
    SELECT 
        concat(nom,' ',prenom) pers,
        id_personne, 
        id_structure 
    FROM md.personne 
    WHERE nom in ('%s') 
        AND prenom in ('%s') 
        AND id_structure != 49
    ;''' % (obs_name,obs_surn)
    obs = pd.read_sql(sql,con)
    return obs


# import TAXREF
taxref = pd.read_sql_table(
    table_name='taxref',
    con=con,
    schema='inpn'
)
taxref = taxref[[
    'regne','phylum','classe','ordre',
    'famille','nom_valide','nom_vern',
    'nom_complet','cd_nom']]

taxref['nom_latin'] = taxref.nom_complet.str.replace(' \(\#ref\)','',regex=True).copy()
# taxref['nom_latin2'] = taxref.nom_latin.str.split(r' \(|, [0-9]',expand=True)[0]
tmp = taxref[
    (taxref.nom_latin=='Euconulus Reinhardt, 1883')&
    (taxref.cd_nom!='192372')].index
taxref.drop(tmp,inplace=True)


# import DATA
path = '/home/colas/Documents/9_PROJETS/4_SICEN/IMPORT/'
file = 'Données Le Cheylas GD_2020.xlsx'
# file = 'DonneesMeF.ods'
df = pd.read_excel(path+file)
# df = pd.read_csv(path+file)

# mise en forme DATA
df.index.name = 'id'
df.rename(columns=dict_columns, inplace=True)
keep_col = df.columns[df.columns.isin(dict_columns.values())]
df = df[keep_col]
df.nom_latin.replace(dict_sp,inplace=True)
df['statut_validation'] = 'validée'
# df['lieu_dit'] = df['localisation'].copy()

if 'EFFC_OIS_Nb_Adult_Mâl' in df.columns:
    df.loc[~df.EFFC_OIS_Nb_Adult_Mâl.isna(),'type_effectif'] = 'Adulte'
    del df['EFFC_OIS_Nb_Adult_Mâl']
if 'id_origine' in df.columns:
    df.loc[~df.id_origine.isna(),'id_origine'] = df.loc[~df.id_origine.isna(),'id_origine'].astype(int).astype(str)
# Concaténation des remarques de localisation
if 'rmq_loc' in df.columns:
    df.loc[~df.rmq_loc.isna(),'localisation'] = df.loc[~df.rmq_loc.isna(),'localisation'] + \
        ', ' + df.loc[~df.rmq_loc.isna(),'rmq_loc']
    del df['rmq_loc']
# Concaténation des remarques observateurs
if 'remarque_obs' in df.columns:
    df.loc[~df.remarque_obs.isna(),'remarque_obs'] = 'Commentaires : ' + \
        df.loc[~df.remarque_obs.isna(),'remarque_obs']
if 'remarque_obsStatut' in df.columns:
    df.loc[~df.remarque_obsStatut.isna(),'remarque_obs'] = df.loc[~df.remarque_obsStatut.isna(),'remarque_obs'] + \
        '; rmq_statut : ' + df.loc[~df.remarque_obsStatut.isna(),'remarque_obsStatut']
    del df['remarque_obsStatut']
if 'nebulosite' in df.columns:
    df.loc[~df.nebulosite.isna(),'remarque_obs'] = df.loc[~df.nebulosite.isna(),'remarque_obs'] + \
        '; nebul : ' + df.loc[~df.nebulosite.isna(),'nebulosite']
    del df['nebulosite']
if 'temperature' in df.columns:
    df.loc[~df.temperature.isna(),'remarque_obs'] = df.loc[~df.temperature.isna(),'remarque_obs'] + \
        '; temp : ' + df.loc[~df.temperature.isna(),'temperature'].astype(str)
    del df['temperature']
if 'vent' in df.columns:
    df.loc[~df.vent.isna(),'remarque_obs'] = df.loc[~df.vent.isna(),'remarque_obs'] + \
        '; ' + df.loc[~df.vent.isna(),'vent']
    del df['vent']
if 'id_waypoint' in df.columns:
    df.loc[~df.id_waypoint.isna(),'id_waypoint'] = df.loc[~df.id_waypoint.isna(),'id_waypoint']\
        .astype(int).astype(str)
if 'precision' not in df.columns:
    df['precision'] = 'GPS'

# format date / time
# df['date_obs'] = df['date_obs'].astype(str).astype(int)
# df['date_obs'] = pd.to_datetime(df['date_obs'])
# df['date_obs'].astype('datetime64')
# pd.to_datetime(df['heure_obs'],format='%H:%M:%S')
# df['heure_obs']

# create geometrie
df['geometrie'] = create_geometry(df.longitude, df.latitude)
if all(df.longitude < 10):
    epsg = 4326
elif all(df.longitude > 900000):
    epsg = 2154
df = df.set_geometry('geometrie', crs=epsg)
if epsg == 4326:
    df.to_crs(2154, inplace=True)
elif epsg == 2154:
    df['longitude'] = df.to_crs(4326).geometrie.x
    df['latitude']  = df.to_crs(4326).geometrie.y
df_union = df.unary_union

# join code_INSEE & Lieu-dit
# commune
com = get_refGeomTable(
    'commune', 'ign_bd_topo', 
    geom_col='geometrie',mask=df_union)
com_union = com.unary_union
# lieu_dit
ldt = get_refGeomTable(
    'lieu_dit', 'ign_bd_topo', colnames=['nom'],
    geom_col='geometrie',mask=com_union, buffer=1000)
ldt.rename(columns={'id': 'id_lieu_dit'}, inplace=True)
ldt_union = ldt.unary_union
# jointure lieu_dit / communes
if 'lieu_dit' in df.columns:
    df['lieu_dit'] = df.lieu_dit.str.lower()
    df = pd.merge(df,ldt[['id_lieu_dit','nom']],left_on='lieu_dit',right_on='nom')
    del df['nom']
    del df['lieu_dit']
else:
    df['id_lieu_dit'] = [
        near(geom,ldt,ldt_union,'id_lieu_dit') 
        for geom in df.geometrie]
df = gpd.sjoin(df,com)
del df['index_right']

# get observateur/validateur
df['observateur'] = normalize_obs(df['observateur'], sep='-')
obs = get_pers(df.observateur)
if not obs.pers.is_unique:
    raise Exception('duplicate observateur')
    ind = obs[(obs.pers == 'GRANGE Benjamin')&(obs.id_structure == 1)].index
    obs.drop(ind, inplace=True)

obs['id_personne'] = obs['id_personne'].astype(str)
obs['id_structure'] = obs['id_structure'].astype(str)
df['observateur'] = df['observateur'].replace(
    to_replace=[*obs.pers],
    value=[*obs.id_personne],
    regex=True)
if 'validateur' in df.columns:
    val = get_pers(df.validateur)
    val['id_personne'] = val['id_personne'].astype(str)
    df['validateur'].replace(*obs.pers,*obs.id_personne, inplace=True)
else:
    df['validateur'] = df['observateur'].str.split('&',expand=True)[0]
for p in obs.iterrows():
    o = p[1]['id_personne']
    s = p[1]['id_structure']
    df.loc[df.observateur.str.contains(o),'structure'] = s

# get numerisateur
num = get_pers(pd.Series(numerisateur))
df['numerisateur'] = num.id_personne.astype(str)[0]

# get id_lot / id_etude
lot = get_refTable('lot_donnee','md',colnames=['libelle'])
etude = get_refTable('etude','md',colnames=['nom_etude'])
df = pd.merge(df,lot,left_on='lot_donnees',right_on='libelle')
del df['libelle']
del df['lot_donnees']
df['id_etude'] = etude.loc[etude.nom_etude == lib_etude,'id_etude'].values[0]

# get protocole
if 'protocole' in df.columns:
    proto = get_refTable('protocole','md',colnames=['libelle'])
    df.protocole = df.protocole \
        .replace(
            to_replace=[
                'Capture à vue (à la main, au filet à papillon...)',
                "Recherche ciblée (bouses, cadavres d'animaux...)"],
            value=['Capture à vue',"Recherche d'indices de présence"])

    df = pd.merge(df,proto, left_on='protocole',right_on='libelle')
    del df['libelle']
    del df['protocole']


# join taxref
if 'cd_nom' in df.columns:
    if df['cd_nom'].dtype == int: df['cd_nom'] = df['cd_nom'].astype(str)
    if 'nom_latin' in taxref.columns: del taxref['nom_latin']
    if 'nom_latin' in df.columns: del df['nom_latin']
    df = df.merge(taxref,on='cd_nom')
else:
    df.nom_latin = df.nom_latin.str.strip()
    tt = taxref[taxref.nom_latin.isin(df.nom_latin.unique())]
    len_taxo = df.nom_latin.unique().shape[0]
    len_taxref = tt.shape[0]
    if len_taxo == len_taxref:
        df = df.merge(tt,on='nom_latin')
        del df['nom_latin']
    else:
        contain = '|'.join(df.nom_latin.unique())
        tt = taxref[taxref.nom_latin.str.contains(contain)]
        len_taxref = tt.shape[0]
        if len_taxo == len_taxref:
            df = df.merge(tt,on='nom_latin')
            del df['nom_latin']
        else:
            raise Exception('error corespondance cd_nom')
            contain = '|'.join(df.nom_latin.str.split(r' \(|, [0-9]',expand=True)[0].unique())
            tt = taxref[taxref.nom_latin2.str.contains(contain)]


# get statuts de reproduction
if 'reprostatut' in df.columns:
    if 'reprocaract' in df.columns:
        df.loc[(~df.reprostatut.isna())&(~df.reprocaract.isna()),'remarque_obs'] = df['remarque_obs'] + \
            '; rmq_repro : ' + df.loc[(~df.reprostatut.isna())&(~df.reprocaract.isna()),'reprocaract']
        df.loc[df.reprostatut.isna(),'reprostatut'] = df.loc[df.reprostatut.isna(),'reprocaract']
        del df['reprocaract']

    sql = 'SELECT unnest(enum_range(null::{0}.{1})) {1}'.format('saisie','enum_reprostatut')
    reprostat = pd.read_sql(sql,con)
    reprostat = pd.concat(
        [reprostat,reprostat.enum_reprostatut.str.split('_',expand=True)],
        axis=1 )
    lst_phyl = df.phylum.unique()
    lst_clas = set([*df.classe.unique()])
    lst_ordr = set([*df.ordre.unique()])
    AMP = set(['Amphibia'])
    CHIR = set([])
    INV = set(['Bivalvia','Gastropoda'])
    MAM = set([])
    ODO = set(['Hexapoda'])
    ordr_ODO = set(['Odonata'])
    ordr_INV = set(['Orthoptera','Lepidoptera'])
    OIS = set(['Aves'])
    REP = set([])

    if any(lst_clas.intersection(AMP)):
        # AMP = list(AMP)
        repro = reprostat[reprostat[0]=='AMP']
        df.loc[df.classe.isin(AMP),'reprostatut'] = df[df.classe.isin(AMP)].reprostatut \
            .replace(
                to_replace='Reproduction confirmée',
                value='Accouplement') \
            .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # df.loc[df.classe.isin(AMP),'reprostatut'] = df[df.classe.isin(AMP)].reprostatut \
            # .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])

    if any(lst_clas.intersection(CHIR)):
        # CHIR = list(CHIR)
        repro = reprostat[reprostat[0]=='CHIR']

    if any(lst_clas.intersection(MAM)):
        # MAM = list(MAM)
        repro = reprostat[reprostat[0]=='MAM']

    if any(lst_clas.intersection(INV)):
        # INV = list(INV)
        repro = reprostat[reprostat[0]=='INV']
        df.loc[df.classe.isin(INV),'reprostatut'] = df[df.classe.isin(INV)].reprostatut \
            .replace(
                to_replace='Reproduction confirmée',
                value='Accouplement') \
            .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # df.loc[df.classe.isin(INV),'reprostatut'] = df[df.classe.isin(INV)].reprostatut \
        #     .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])

    if any(lst_clas.intersection(ODO)) and any(lst_ordr.intersection(ordr_INV)):
        # ODO = list(ODO)
        # ordr_INV = list(ordr_INV)
        repro = reprostat[reprostat[0]=='INV']
        df.loc[(df.classe.isin(ODO))&(df.ordre.isin(ordr_INV)),'reprostatut'] = \
            df[(df.classe.isin(ODO))&(df.ordre.isin(ordr_INV))].reprostatut \
            .replace(
                to_replace='Reproduction confirmée',
                value='Accouplement') \
            .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # df.loc[(df.classe.isin(ODO))&(df.ordre.isin(ordr_INV)),'reprostatut'] = \
        #     df[(df.classe.isin(ODO))&(df.ordre.isin(ordr_INV))].reprostatut \
        #     .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # ODO = set(ODO)

    if any(lst_clas.intersection(ODO)) and any(lst_ordr.intersection(ordr_ODO)):
        # ODO = list(ODO)
        # ordr_ODO = list(ordr_ODO)
        repro = reprostat[reprostat[0]=='ODO']
        df.loc[(df.classe.isin(ODO))&(df.ordre.isin(ordr_ODO)),'reprostatut'] = \
            df[(df.classe.isin(ODO))&(df.ordre.isin(ordr_ODO))].reprostatut \
            .replace(
                to_replace=['Accouplement','Reproduction confirmée','Reproduction possible','Reproduction probable'],
                value=['Tandem','Exuvie/émergence','Mâles+Femelles','Immature']) \
            .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # df.loc[(df.classe.isin(ODO))&(df.ordre.isin(ordr_ODO)),'reprostatut'] = \
        #     df[(df.classe.isin(ODO))&(df.ordre.isin(ordr_ODO))].reprostatut \
        #     .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])

    if any(lst_clas.intersection(OIS)):
        # OIS = list(OIS)
        repro = reprostat[reprostat[0]=='OIS']
        df.loc[df.classe.isin(OIS),'reprostatut'] = df[df.classe.isin(OIS)].reprostatut \
            .replace(
                to_replace='Déplacement (marche, vol, nage)',
                value='Fuite - envol') \
            .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])
        # df.loc[df.classe.isin(OIS),'reprostatut'] = df[df.classe.isin(OIS)].reprostatut \
        #     .replace(to_replace=[*repro[1]],value=[*repro.enum_reprostatut])

    if any(lst_clas.intersection(REP)):
        # REP = list(REP)
        repro = reprostat[reprostat[0]=='REP']










df.to_postgis(
    name='saisie_observation',
    con=con,
    schema='saisie',
    if_exists='append',
    index=False,
    geom_col='geometrie',
)