import pyarrow.parquet as pq
import pandas as pd
import re
import numpy as np
from sklearn.linear_model import LinearRegression
import math

saldos = pq.read_table('0saldos.parquet').to_pandas()
saldos = saldos.loc[saldos['TipoDocum'] == 'C ']
saldos.info()

saldos.isna().sum()

def perdidas(matrix):
    # Compare the last element with all other elements in the row (excluding the last one)
    results = [  np.max(matrix[i][matrix[i] > 0][-4:] ) - np.max(matrix[i][matrix[i] > 0][-1] ) for i in range(matrix.shape[0])]
    
    # Convert the list of results to a column vector
    result_array = np.array(results).reshape(-1, 1)
    return result_array

saldos['SALDO_202209'] = (saldos['SALDO_202208'] + saldos['SALDO_202210']) / 2
# Filtrar las columnas que coinciden con el regex
# Sumar las columnas

saldos['total'] = saldos.filter(regex=regex).sum(axis=1)
saldos['mediaSaldo'] = saldos.filter(regex=regex).mean(axis=1)

saldos = saldos.loc[saldos['total'] > 0]

saldos_array = []
for i in saldos.filter(regex=regex).columns:
    if len(saldos_array) >= 1:
        saldos_array[0] = np.hstack([saldos_array[0], np.array(saldos[i].values).reshape(len(saldos[i].values), 1)])
    else:

        saldos_array.append(np.array(saldos[i].values).reshape(len(saldos[i].values), 1))

saldos['posiblesPerdidas'] =perdidas(saldos_array[0])

saldos.drop(columns=saldos.filter(regex=regex).columns, axis=1, inplace=True)
saldos.info()

transferencias = pq.read_table('0transferencias.parquet').to_pandas()
transferencias.sort_values(by='FechaEfectiva', ascending=True, inplace=True)
transferencias.FechaEfectiva = pd.to_datetime(transferencias.FechaEfectiva, format='%Y-%m-%d')

# Agrupar las transacciones por mes y sumar los valores
transferencias = transferencias.groupby(
    [transferencias['Contrato'], transferencias['FechaEfectiva'].dt.to_period('M')], as_index=True
).agg(
    ValorTransaccion=('ValorNeto', 'sum'),
    Productos=('PlanProducto', 'first'),
    User=('Contrato', 'first'),
    Tipo=('TipoOper', 'first'),
)

transferencias = transferencias.groupby(
    [transferencias['User']], as_index=True
).agg(
    ValorTransaccion=('ValorTransaccion', 'mean'),
    NumberOfTransactions=('ValorTransaccion', 'count'),
)
print(transferencias.info())
transferencias['Users'] = transferencias.index
transferencias

def check_last_less_than_others(matrix):
    last_elements = matrix[:, -1]
    # Compare the last element with all other elements in the row (excluding the last one)
    results = [last_elements[i] < (np.max((matrix[i, -4:-3])) * 0.3) for i in range(matrix.shape[0])]
    # Convert the list of results to a column vector
    result_array = np.array(results).reshape(-1, 1)
    return result_array


saldos['activeCases'] = check_last_less_than_others(saldos_array[0])
clientes = pq.read_table('0clientes.parquet').to_pandas()
clientes = clientes.loc[clientes['TIPODOCUM'] == 'C']
clientes.drop(
    columns=['EnvioExtractos', 'TIPODOCUM'], inplace=True)

# saldos = saldos.merge(clientes, how="left", left_on=['NroDocum'], right_on=['NroDocum'])
saldos = saldos.join(clientes.set_index("NroDocum"), on="NroDocum")

saldos['edad'] = saldos['FecNacim']
saldos = saldos.astype({'edad': 'str'})
saldos['edad'] = saldos['edad'].str.slice(0, 4)
saldos = saldos.astype({'edad': 'int'})
saldos['edad'] = -(saldos['edad'] - 2022)

saldos

def predictions(matrix):
    mask_array = []
    for i in range(matrix.shape[0]):
        # Aqui suve a 90 sin -3
        serie_temporal = matrix[i, :-3]

        try:
            serie = pd.Series(serie_temporal)

            # Calcula el promedio móvil con una ventana de tamaño window_size
            serie_temporal = serie.rolling(window=3, min_periods=1).mean().dropna().values[-3:]
            
            tiempo = np.arange(len(serie_temporal)).reshape(-1, 1)
            # Crea y ajusta un modelo de regresión lineal
            modelo = LinearRegression()
            modelo.fit(tiempo, serie_temporal)
            # Hacer predicciones para los siguientes tres valores
            siguientes_tres_valores = np.array(
                [[len(serie_temporal)], [len(serie_temporal) + 1], [len(serie_temporal) + 2]])

            predicciones = list((modelo.predict(siguientes_tres_valores)))

            predict_2 = (predicciones[-2]) < (serie_temporal[-1] * 0.3)
            predict_3 = (predicciones[-3]) < (serie_temporal[-1] * 0.3)
            predict_1 = (predicciones[-1]) < (serie_temporal[-1] * 0.3)
            if predict_1 or predict_2 or predict_3:
                mask_array.append(True)
            else:
                mask_array.append(False)

        except:
            mask_array.append(False)

    return mask_array


def tendencia(matrix):
    mask_array = []
    for i in range(matrix.shape[0]):
        serie_temporal = matrix[i, :-3]
        tiempo = np.arange(len(serie_temporal)).reshape(-1, 1)
        modelo = LinearRegression()
        modelo.fit(tiempo, serie_temporal)
        pendiente = modelo.coef_[0]
        mask_array.append(pendiente)

    return mask_array


def drop_percent(matrix):
    drop_array = []
    for i in range(matrix.shape[0]):
        y = list(matrix[i])
        y = [i for i in y if i > 0]
        start = -2
        try:
            porcentaje_caida = ((y[-1]) / (y[start] * 0.01)) - 100
            drop_array.append(porcentaje_caida)
        except:
            drop_array.append(0)
    return drop_array


saldos['porcentajeCaida'] = drop_percent(saldos_array[0])
saldos['slope'] = tendencia(saldos_array[0])
saldos['prediction'] = predictions(saldos_array[0])

saldos

baja_true = saldos.loc[(saldos['activeCases'] == True) & (saldos['slope'] < 0)]
sube_true = saldos.loc[(saldos['activeCases'] == True) & (saldos['slope'] > 0)]
baja_false = saldos.loc[(saldos['activeCases'] == False) & (saldos['slope'] < 0)]
sube_false = saldos.loc[(saldos['activeCases'] == False) & (saldos['slope'] > 0)]

baja_true

a = len(baja_true.loc[baja_true.prediction == True].values)

b = len(sube_true.loc[sube_true.prediction == True].values)

verdaderos = len(saldos.loc[saldos['activeCases'] == True].index.values)

print('TOTAL DE CASOS ACTIVOS: ', verdaderos)
print('CASOS ACTIVOS CON PREDICCION -30%: ', (a + b))

a = len(baja_true.loc[baja_true.slope < 0].values)

verdaderos = len(saldos.loc[saldos['activeCases'] == True].index.values)

print('CASOS ACTIVOS SLOPE: ', (a))

a = len(baja_false.loc[baja_false.prediction == True].values)

b = len(sube_false.loc[sube_false.prediction == True].values)

verdaderos = len(saldos.loc[saldos['activeCases'] == False].index.values)

print('TOTAL DE NO CASOS ACTIVOS: ', verdaderos)
print('CASOS NO ACTIVOS CON PREDICCION -30%: ', (a + b))

a = len(baja_false.loc[baja_false.slope < 0].values)

b = len(sube_false.loc[sube_false.slope < 0].values)

verdaderos = len(saldos.loc[saldos['activeCases'] == False].index.values)

print('CASOS NO ACTIVOS SLOPE: ', (a))
saldos['totalPercent'] = saldos['slope'] / saldos['total']

# Mostrar el DataFrame modificado
saldos['ValorTransaccion'] = saldos['ValorTransaccion'].fillna(saldos['total'] / 1000)
saldos['ValorTransaccion'].fillna(0, inplace=True)
saldos['totalPercent'] = saldos['totalPercent'].fillna(saldos['porcentajeCaida'] * 10)



saldos

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier  # Importar RandomForest
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.preprocessing import LabelEncoder
from sklearn.impute import SimpleImputer
import pandas as pd

# Suponemos que 'data' es tu DataFrame original y que 'saldos' ya ha sido cargado correctamente
data = saldos.copy()

# Imputación de valores faltan

# (Asumiendo que necesitas transformar 'prediction' de categórica a numérica si aún no está hecho)
le = LabelEncoder()
data['prediction'] = le.fit_transform(data['prediction'])

# Separar las variables predictoras y el objetivo
X = data[['prediction', 'porcentajeCaida', 'totalPercent', 'ValorTransaccion']]
y = data['activeCases']
rd = 5

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=rd)

# Modelo de Random Forest
forest_model = RandomForestClassifier(criterion='log_loss', n_estimators=10, random_state=rd, n_jobs=3)  # Usar 100 árboles
forest_model.fit(X_train, y_train)

# Predicciones y evaluación del modelo
predicciones_forest = forest_model.predict(X_test)
reporte_clasificacion_forest = classification_report(y_test, predicciones_forest)
matriz_confusion_forest = confusion_matrix(y_test, predicciones_forest)
accuracy_forest = accuracy_score(y_test, predicciones_forest)

# Imprimir los resultados
print("Reporte de clasificación (Random Forest):\n", reporte_clasificacion_forest)
print("Matriz de confusión (Random Forest):\n", matriz_confusion_forest)
print(f'Accuracy del modelo (Random Forest): {accuracy_forest:.2f}')

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

# Definición del modelo
# Definición del espacio de parámetros a probar
param_dist = {
    'n_estimators': randint(10, 50),
    'criterion': ['gini', 'entropy', ],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': randint(2, 11)
}

# Crear el objeto RandomizedSearchCV
random_search = RandomizedSearchCV(estimator=forest_model, param_distributions=param_dist, n_iter=10, cv=5, scoring='accuracy', random_state=rd)

# Ejecutar la búsqueda aleatoria
random_search.fit(X_train, y_train)

# Mejores parámetros encontrados
print("Mejores parámetros:", random_search.best_params_)

# Mejor modelo encontrado
best_forest_random = random_search.best_estimator_

# Evaluación del mejor modelo

predicciones_best_forest_random = best_forest_random.predict(X_test)
reporte_clasificacion_forest = classification_report(y_test, predicciones_forest)
matriz_confusion_forest = confusion_matrix(y_test, predicciones_forest)
accuracy_forest = accuracy_score(y_test, predicciones_forest)

# Imprimir los resultados
print("Reporte de clasificación (Random Forest):\n", reporte_clasificacion_forest)
print("Matriz de confusión (Random Forest):\n", matriz_confusion_forest)
print(f'Accuracy del modelo (Random Forest): {accuracy_forest:.2f}')



print("Accuracy del mejor modelo (Randomized):", accuracy_score(y_test, predicciones_best_forest_random))

print("Importancia de los predictores en el modelo")
print("-------------------------------------------")
importancia_predictores = pd.DataFrame(
    {'predictor': forest_model.feature_names_in_,
     'importancia': forest_model.feature_importances_}
)
importancia_predictores.sort_values('importancia', ascending=False)

dinero = saldos.copy()

dinero = dinero.loc[dinero['activeCases'] == True]
dinero = dinero.join(clientes.set_index("NroDocum"), on="NroDocum")
dinero['posiblesPerdidas']