import os

import mongoengine
from bson import ObjectId
from mongoengine import connect as mongo_connect
from pandas import DataFrame


def connect_mongo_db(username=os.environ['MONGO_USER'] ,
                      password=os.environ['MONGO_PASSWD'] ,
                      host=os.environ['MONGO_URI'],
                      dbname=os.environ['MONGO_DB'] ):
    
    c = mongo_connect(dbname,
                  username=username,
                  password=password,
                  host=host,
                  authentication_source='admin',
                  alias='dblabtests')


def mongo_upload_results(resultsmodel, results: DataFrame, datamodel,
                         data: DataFrame, filehash: str, org_id: ObjectId,
                         project_id: ObjectId, material_id: ObjectId,
                         user_id: ObjectId):

    for idx, res in results.iterrows():

        #upload results
        meta['filehash'] = filehash
        meta['org_id'] = org_id
        meta['project_id'] = project_id
        meta['material'] = material_id
        meta['user_id'] = user_id

        #check if result in db
        #n = CITTSiffness.objects(**meta).count()

        # write data
        data_dict = res.to_dict()
        data_dict.update(meta)

        f = resultsmodel(**data_dict).save()

        # upload data
        data_sel = data[idx_fit]

        # required data
        data_out = dict(
            time=data_sel.index,
            F=list(data_sel['F']),
            N=list(data_sel['N']),
            s_hor_1=list(data_sel['s_hor_1']),
            s_hor_2=list(data_sel['s_hor_2']),
            s_hor_sum=list(data_sel['s_hor_sum']),
        )
        #optional data
        for col in ['S_piston']:
            if col in data_sel.columns:
                data_out[col] = data_sel[col]

        g = datamodel(result=f.id, **data_out).save()


def mongo_get_results(resultsmodel, results: DataFrame, datamodel,
                      data: DataFrame, filehash: str, org_id: ObjectId,
                      project_id: ObjectId, material_id: ObjectId,
                      user_id: ObjectId):

    return True

def fetch_recursive(data, fetch_parameter=['norm', 'limits', 'assign_machine']):
    
    fields = data._fields
    
    data_out = data.to_mongo().to_dict()
    
    for par in fetch_parameter:
        if par in fields.keys():
            
            try:
                # if is LazyReferenceField
                if isinstance(fields[par], mongoengine.fields.LazyReferenceField):
                        d = data[par].fetch()
                else:
                        d = data[par]
            
            except:
                continue
            
            if d  is None: 
                continue
            
            data_out[par] = d.to_mongo().to_dict()
    
    return data_out

def mongo_to_dict(data, drop_parameters=['_cls','user_id', 'org_id', 'project_id']):
    '''
    data: dict
    
    '''    
    for key in list(data.keys()):
        if key in drop_parameters:
            del data[key]  # Remove the unwanted key
        elif isinstance(data[key], dict):
            mongo_to_dict(data[key])  # Recurse into nested dictionaries
        elif isinstance(data[key], list):  # Add this line to process lists
            for i, item in enumerate(data[key]):
                if isinstance(item, ObjectId):
                    data[key][i] = str(item)
                elif isinstance(item, dict):
                    mongo_to_dict(item, drop_parameters)  # Recurse into nested dictionaries in list
        else:
            # process data
            if isinstance(data[key], ObjectId):
                data[key] = str(data[key])
    
    return data