# Verificando dados nulos no dataset df_mercado
nulls_mercado = df_mercado.isnull().sum()
print("Dados nulos em df_mercado:")
print(nulls_mercado)

# Verificando dados nulos no dataset df_transacoes
nulls_transacoes = df_transacoes.isnull().sum()
print("Dados nulos em df_transacoes:")
print(nulls_transacoes)

# Filtrando df_mercado onde há valores nulos
df_mercado_nulos = df_mercado[df_mercado.isnull().any(axis=1)]
display(df_mercado_nulos)
# Analisando os valores nulos com a matriz do missingno
msno.matrix(df_mercado)
plt.show()

# Filtrando df_transacoes onde há valores nulos
df_transacoes_nulos = df_transacoes[df_transacoes.isnull().any(axis=1)]
display(df_transacoes_nulos)

msno.matrix(df_transacoes)
plt.show()

# Fazendo forward fill para ambas as tabelas na coluna de dolar
df_mercado['Dolar'].fillna(method='ffill', inplace=True)
df_transacoes['Dolar'].fillna(method='ffill', inplace=True)

display(df_mercado.isna().sum())
display(df_transacoes.isna().sum())

# Removendo dados nulos de df_mercado
df_mercado.dropna(inplace=True)

# Removendo dados nulos de df_transacoes
df_transacoes.dropna(inplace=True)

# Verificando se ainda há dados nulos em df_mercado
nulls_mercado = df_mercado.isnull().sum()
print("Dados nulos em df_mercado após remoção:")
print(nulls_mercado)

# Verificando se ainda há dados nulos em df_transacoes
nulls_transacoes = df_transacoes.isnull().sum()
print("Dados nulos em df_transacoes após remoção:")
print(nulls_transacoes)

# Selecionando apenas as variáveis numéricas de cada dataset
numeric_cols_mercado = df_mercado.select_dtypes(include=['float64', 'int64']).columns
numeric_cols_transacoes = df_transacoes.select_dtypes(include=['float64', 'int64']).columns

# Número de variáveis numéricas em cada dataset
num_numeric_cols_mercado = len(numeric_cols_mercado)
num_numeric_cols_transacoes = len(numeric_cols_transacoes)

# Configurando o estilo do Seaborn
sns.set(style="whitegrid")

# Criando subplots para df_mercado
fig, axes = plt.subplots(num_numeric_cols_mercado, 3, figsize=(15, 5 * num_numeric_cols_mercado))
fig.suptitle('Distribuição das Variáveis Numéricas - df_mercado', fontsize=16)

for i, col in enumerate(numeric_cols_mercado):
    sns.histplot(df_mercado[col], kde=True, ax=axes[i, 0], color='skyblue')
    axes[i, 0].set_title(f'Distribuição com KDE - {col}')
    
    sns.boxplot(x=df_mercado[col], ax=axes[i, 1], color='lightgreen')
    axes[i, 1].set_title(f'Boxplot - {col}')
    
    sns.violinplot(x=df_mercado[col], ax=axes[i, 2], color='lightcoral')
    axes[i, 2].set_title(f'Violin Plot - {col}')

plt.tight_layout(rect=[0, 0, 1, 0.96])
plt.show()

# Criando subplots para df_transacoes
fig, axes = plt.subplots(num_numeric_cols_transacoes, 3, figsize=(15, 5 * num_numeric_cols_transacoes))
fig.suptitle('Distribuição das Variáveis Numéricas - df_transacoes', fontsize=16)

for i, col in enumerate(numeric_cols_transacoes):
    sns.histplot(df_transacoes[col], kde=True, ax=axes[i, 0], color='skyblue')
    axes[i, 0].set_title(f'Distribuição com KDE - {col}')
    
    sns.boxplot(x=df_transacoes[col], ax=axes[i, 1], color='lightgreen')
    axes[i, 1].set_title(f'Boxplot - {col}')
    
    sns.violinplot(x=df_transacoes[col], ax=axes[i, 2], color='lightcoral')
    axes[i, 2].set_title(f'Violin Plot - {col}')

plt.tight_layout(rect=[0, 0, 1, 0.96])
plt.show()

def detect_outliers_iqr(df, column):
    Q1 = df[column].quantile(0.25)
    Q3 = df[column].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
    outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)]
    return outliers

# Detectando outliers para as variáveis 'Price' e 'Amount'
outliers_price = detect_outliers_iqr(df_transacoes, 'Price')
outliers_amount = detect_outliers_iqr(df_transacoes, 'Amount')

# Mostrando os outliers detectados
display(outliers_price)
display(outliers_amount)

#Observando melhor os dados dos outliers

display(outliers_price.describe())
display(outliers_amount.describe())

df_transacoes[df_transacoes['Amount'] == 0]

sns.histplot(data=df_transacoes, x='Price', hue='Product', multiple='stack')

plt.show()

df_transacoes = df_transacoes[df_transacoes['Amount'] > 0]

# Calculando os percentis
percentiles = np.percentile(df_transacoes['Amount'], np.arange(0, 101))

# Configurando o estilo do Seaborn
sns.set(style="whitegrid")

# Criando o gráfico
plt.figure(figsize=(12, 6))
sns.lineplot(x=np.arange(0, 101), y=percentiles, marker='o', color='b')

# Adicionando títulos e rótulos
plt.title('Distribuição dos Percentis de Amount', fontsize=16)
plt.xlabel('Percentil', fontsize=14)
plt.ylabel('Amount', fontsize=14)

# Adicionando ticks e valores em 45 graus a cada 5 percentis
for i in range(0, 101, 5):
    plt.text(i, percentiles[i], f'{percentiles[i]:.2f}', ha='right', va='bottom', rotation=45, fontsize=8)

# Exibindo o gráfico
plt.show()

# Verificando dados duplicados no dataset df_mercado
duplicated_mercado = df_mercado.duplicated()
print(f"Número de linhas duplicadas em df_mercado: {duplicated_mercado.sum()}")

# Exibindo as linhas duplicadas em df_mercado
if duplicated_mercado.sum() > 0:
    display(df_mercado[duplicated_mercado])

# Verificando dados duplicados no dataset df_transacoes
duplicated_transacoes = df_transacoes.duplicated()
print(f"Número de linhas duplicadas em df_transacoes: {duplicated_transacoes.sum()}")

# Exibindo as linhas duplicadas em df_transacoes
if duplicated_transacoes.sum() > 0:
    display(df_transacoes[duplicated_transacoes])

# Heatmap for df_mercado
plt.figure(figsize=(10, 8))
sns.heatmap(df_mercado.select_dtypes(include=['float64', 'int64']).corr(), annot=True, cmap='coolwarm')
plt.title('Heatmap de correlação para df_mercado')
plt.show()

# Heatmap for df_transacoes
plt.figure(figsize=(10, 8))
sns.heatmap(df_transacoes.select_dtypes(include=['float64', 'int64']).corr(), annot=True, cmap='coolwarm')
plt.title('Heatmap de correlação para df_transacoes')
plt.show()

sns.scatterplot(data=df_mercado,
            x = 'Price',
            y = 'CBOT')

plt.title('Scatterplot de Price x CBOT')
plt.xlabel('Price')
plt.ylabel('CBOT')
plt.show()

sns.scatterplot(data=df_mercado,
            x = 'Price',
            y = 'CBOT',
            hue = 'Product',
            )

plt.title('Scatterplot de Price x CBOT')
plt.xlabel('Price')
plt.ylabel('CBOT')
plt.show()

# Calculando a correlação entre Price e CBOT para cada produto
correlation_soja = df_mercado[df_mercado['Product'] == 'Soja'][['Price', 'CBOT']].corr().iloc[0, 1]
correlation_milho = df_mercado[df_mercado['Product'] == 'Milho'][['Price', 'CBOT']].corr().iloc[0, 1]

print(f"Correlação entre Price e CBOT para Soja: {correlation_soja}")
print(f"Correlação entre Price e CBOT para Milho: {correlation_milho}")

plt.figure(figsize=(15, 9))
sns.pairplot(df_mercado, hue='Product')
plt.show()

sns.pairplot(df_transacoes, hue='Product')
plt.show()

plt.figure(figsize=(15, 9))
sns.pairplot(df_mercado, hue='Company')
plt.show()

sns.pairplot(df_transacoes, hue='Company')
plt.show()

# Group by 'Date' and plot each group
df_mercado.select_dtypes(include=['float64', 'int64']).plot(subplots=True, figsize=(15, 10))

# Plotando as variáveis numéricas com hue pelo 'Product'
fig, axes = plt.subplots(len(numeric_cols_mercado), 1, figsize=(15, 5 * len(numeric_cols_mercado)))

for i, col in enumerate(numeric_cols_mercado):
    sns.lineplot(data=df_mercado, x=df_mercado.index, y=col, hue='Product', ax=axes[i])
    axes[i].set_title(f'{col} ao longo do tempo por Produto')
    axes[i].set_xlabel('Data')
    axes[i].set_ylabel(col)

plt.tight_layout()
plt.show()

# Plotando as variáveis numéricas com hue pelo 'Product'
fig, axes = plt.subplots(len(numeric_cols_transacoes), 1, figsize=(15, 5 * len(numeric_cols_transacoes)))

resampled_df_transacoes = df_transacoes.resample('D').last()

for i, col in enumerate(numeric_cols_transacoes):
    sns.lineplot(data=resampled_df_transacoes, x=resampled_df_transacoes.index, y=col, hue='Product', ax=axes[i])
    axes[i].set_title(f'{col} ao longo do tempo por Produto')
    axes[i].set_xlabel('Data')
    axes[i].set_ylabel(col)

plt.tight_layout()
plt.show()

df_mercado_M = df_mercado.select_dtypes(exclude='category').resample('M').mean()
df_transacoes_M = df_transacoes.select_dtypes(exclude='category').resample('M').mean().iloc[:, 1:]

df_full = df_mercado_M.join(df_transacoes_M, lsuffix='_mercado', rsuffix='_transacoes')

df_full.head()

sns.heatmap(df_full.corr(), annot = True)

display(df_transacoes.head())
display(df_mercado.head())

# Creating crosstab for df_mercado
crosstab_mercado = pd.crosstab(index=df_mercado['Origin_state'], columns=[df_mercado['Company'], df_mercado['Product']])

# Crosstab for df_mercado
plt.figure(figsize=(15, 6))
sns.heatmap(crosstab_mercado, annot=True, fmt="d", cmap="YlGnBu", annot_kws={'size': 8})  
plt.title('Heatmap de Company e Product por Origin_state - df_mercado', fontsize=10)  
plt.xticks(fontsize=8)  
plt.yticks(fontsize=8)
plt.show()

# Creating crosstab for df_transacoes
crosstab_transacoes = pd.crosstab(index=df_transacoes['origin_state'], columns=[df_transacoes['Company'], df_transacoes['Product']])

# Crosstab for df_transacoes 
plt.figure(figsize=(15, 6))
sns.heatmap(crosstab_transacoes, annot=True, fmt="d", cmap="YlGnBu", annot_kws={'size': 8})  
plt.title('Heatmap de Company e Product por origin_state - df_transacoes', fontsize=10)  
plt.xticks(fontsize=8)  
plt.yticks(fontsize=8) 
plt.show()

df_transacoes['Seller ID'].value_counts().head(10).plot(kind='bar', figsize=(15, 6), color='skyblue')

df_transacoes['Seller ID'].value_counts(normalize=True)[:10].sum() * 100

mask = df_merc_pre_proc.duplicated(['date', 'product', 'origin_state', 'origin_city', 'company'], keep=False)

df_merc_pre_proc[mask].sort_values(['date', 'product', 'origin_state', 'origin_city', 'company'])

df_merc_join = (
    df_merc_pre_proc
    .groupby(['date', 'product', 'origin_state', 'origin_city', 'company'])
    .agg({'price': 'median', 'cbot': 'median'}).reset_index().dropna()
)

mask = df_merc_join.duplicated(['date', 'product', 'origin_state', 'origin_city', 'company'], keep=False)

df_merc_join[mask].sort_values(['date', 'product', 'origin_state', 'origin_city', 'company'])

df_completo_v1  = df_trans_pre_pros.merge(
    df_merc_join,
    left_on=['date', 'product', 'origin_state', 'origin_city', 'company'],
    right_on=['date', 'product', 'origin_state', 'origin_city','company'],
    suffixes=('_trans','_merc'),
    how='left'
)

display(df_completo_v1.isna().sum())

df_completo_v1.shape

df_completo_v1

msno.matrix(df_completo_v1)
plt.show()

df_completo_v1.tail()

# Função para preencher valores nulos com a mediana com base em múltiplos agrupamentos
def preencher_nulos_com_mediana(df, colunas_grupo, coluna_alvo):
    medianas = df.groupby(colunas_grupo)[coluna_alvo].transform('median')
    df[coluna_alvo].fillna(medianas, inplace=True)

# Definir as colunas para agrupamento
df_completo_v1['week'] = df_completo_v1['date'].dt.isocalendar().week
colunas_grupo = ['product', 'week', 'origin_city', 'company']

# Preencher valores nulos para 'price_merc' e 'cbot'
preencher_nulos_com_mediana(df_completo_v1, colunas_grupo, 'price_merc')
preencher_nulos_com_mediana(df_completo_v1, colunas_grupo, 'cbot')

# Verificar se ainda há valores nulos restantes
print(df_completo_v1.isnull().sum())

msno.matrix(df_completo_v1)
plt.show()

df_completo_v1[df_completo_v1.isna().any(axis=1)]

# Definir as colunas para agrupamento
colunas_grupo = ['product']

# Preencher valores nulos para 'price_merc' e 'cbot'
preencher_nulos_com_mediana(df_completo_v1, colunas_grupo, 'price_merc')
preencher_nulos_com_mediana(df_completo_v1, colunas_grupo, 'cbot')

# Verificar se ainda há valores nulos restantes
print(df_completo_v1.isnull().sum())

mask2 = df_merc_pre_proc['cbot'].isin(df_completo_v1['cbot'])
df_merc_pre_proc_sem_intersecao = df_merc_pre_proc[~mask2]
df_merc_pre_proc_sem_intersecao.head()

assert df_merc_pre_proc_sem_intersecao['cbot'].isin(df_completo_v1['cbot']).sum() == 0

display(df_completo_v1.columns)

display(df_merc_pre_proc_sem_intersecao.columns)

df_completo_v1['destination_city'] = None
df_completo_v1['destination_state'] = None

df_merc_pre_proc_sem_intersecao['seller_id'] = None
df_merc_pre_proc_sem_intersecao['week'] = None
df_merc_pre_proc_sem_intersecao.rename(columns={'price': 'price_merc'}, inplace=True)

df_completo_v2 = pd.concat([df_completo_v1, df_merc_pre_proc_sem_intersecao], axis=0, ignore_index=True)

df_completo_v2.drop('week', axis=1, inplace=True)

df_completo_v2['week_of_year'] = df_completo_v2['date'].dt.isocalendar().week
df_completo_v2['day_of_week'] = df_completo_v2['date'].dt.day_name()

df_completo_v2.sort_values('date', inplace=True)
df_completo_v2.head()

df_completo_v2

df_completo_v2.info()

def impute_missing_values_with_mode(df, group_cols, target_cols):
    for col in target_cols:
        mode_values = df.groupby(group_cols)[col].transform(lambda x: x.mode()[0] if not x.mode().empty else x)
        df[col].fillna(mode_values, inplace=True)

# Definindo as colunas para agrupamento e as colunas alvo
group_cols = ['company', 'product']
target_cols = ['destination_city', 'destination_state']

# Imputando os valores nulos com a moda
impute_missing_values_with_mode(df_completo_v2, group_cols, target_cols)

# Verificando se ainda há valores nulos restantes
print(df_completo_v2.isnull().sum())

df_completo_v2.info()

df_completo_v2.tail()

df_completo_v2.dropna(subset='seller_id', inplace=True)

df_completo_v2.info()

df_completo_v2.tail()

df_completo_v2.info()

# Convertendo colunas do tipo object para category
df_completo_v2 = df_completo_v2.apply(lambda x: x.astype('category') if x.dtype == 'object' else x)

# Verificando a conversão
df_completo_v2.info()

df_completo_v2.tail()

df_completo_v3 = df_completo_v2.drop(columns=['price_trans', 'amount'])

df_completo_v3.head()

df_completo_v4_test = df_completo_v3.copy()

# Convert 'seller_id' to string to ensure uniform data type
df_completo_v4_test['seller_id'] = df_completo_v4_test['seller_id'].astype(str)


df_completo_v4_test.head()

from sktime.classification.dummy import DummyClassifier
from sktime.classification.interval_based import TimeSeriesForestClassifier
from sktime.transformations.panel.compose import ColumnConcatenator
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, roc_auc_score
from sktime.datatypes._panel._convert import from_2d_array_to_nested
from sklearn.preprocessing import LabelEncoder
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from tqdm import tqdm
import gc

display(df_pre_modelo_.tail())

df_pre_modelo_.shape

X = df_pre_modelo_.drop(['seller_id'],axis=1)
y = df_pre_modelo_['seller_id']

X.head()

# Dividindo em treinamento e teste considerando a ordem temporal
X_train, X_test = X[X['date'] < '2024-11-04'], X[X['date'] >= '2024-11-04']
y_train, y_test = y[:X_train.shape[0]], y[X_train.shape[0]:]

display(X_train.shape,X_test.shape)
display(y_train.shape,y_test.shape)

le_target  = LabelEncoder()
y_train_encoded = le_target.fit_transform(y_train)

display(X_train.head(), X_train.shape)
display(y_train_encoded[5], y_train.shape)

import numpy as np
from sklearn.model_selection import TimeSeriesSplit, cross_validate

#garantir que o treino tem 
unique_classes = np.unique(y_train_encoded)
class_mapping = {cls: idx for idx, cls in enumerate(unique_classes)}
y_train_mapped = np.array([class_mapping[cls] for cls in y_train_encoded])

# Drop the 'date' column from X_train
X_train_no_date = X_train.drop(columns=['date'])

# Encode categorical variables in X_train_no_date
categorical_cols = X_train_no_date.select_dtypes(include=['category', 'object']).columns
label_encoders = {col: LabelEncoder().fit(X_train_no_date[col]) for col in categorical_cols}

for col, le in label_encoders.items():
    X_train_no_date[col] = le.transform(X_train_no_date[col])

# Lista de modelos para validação cruzada
models = {
    'DecisionTreeClassifier': DecisionTreeClassifier(max_depth=6, min_samples_split=2),
    'RandomForestClassifier': RandomForestClassifier(n_estimators=100, max_depth=6),
    'ExtraTreesClassifier': ExtraTreesClassifier(n_estimators=100, max_depth=6),
}

# Dicionário para armazenar os resultados
cv_results = {}

# Utilizando uma janela de 500 para o time series split
tscv = TimeSeriesSplit(max_train_size=500)

# Aplicando cross-validation para cada modelo
for model_name, model in models.items():
    scores = cross_validate(model, X_train_no_date, y_train_mapped, cv=tscv, scoring=['precision_weighted', 'accuracy', 'recall_weighted'], return_train_score=True, n_jobs=-1)
    cv_results[model_name] = scores
    print(f'{model_name} - Test Precision: {scores["test_precision_weighted"].mean():.4f} (+/- {scores["test_precision_weighted"].std():.4f})')
    print(f'{model_name} - Train Precision: {scores["train_precision_weighted"].mean():.4f} (+/- {scores["train_precision_weighted"].std():.4f})')

# Exibindo os resultados
cv_results

# Descompactar as listas no dicionário e criar um DataFrame
results_df = pd.DataFrame({model: {metric: scores for metric, scores in cv_results[model].items()} for model in cv_results})

# Exibir o DataFrame
results_df

# Calcular a média para cada métrica no dicionário
mean_results = {model: {metric: np.mean(scores) for metric, scores in cv_results[model].items()} for model in cv_results}

# Criar um DataFrame a partir dos resultados médios
results_df = pd.DataFrame(mean_results)

# Exibir o DataFrame
results_df.T

from sktime.classification.dummy import DummyClassifier
from sktime.classification.interval_based import TimeSeriesForestClassifier
from sklearn.pipeline import make_pipeline

# Ensure y_train has consecutive integer values
unique_classes = np.unique(y_train_encoded)
class_mapping = {cls: idx for idx, cls in enumerate(unique_classes)}
y_train_mapped = np.array([class_mapping[cls] for cls in y_train_encoded])

# Drop the 'date' column from X_train
X_train_no_date = X_train.drop(columns=['date'])

# Encode categorical variables in X_train_no_date
categorical_cols = X_train_no_date.select_dtypes(include=['category', 'object']).columns
label_encoders = {col: LabelEncoder().fit(X_train_no_date[col]) for col in categorical_cols}

for col, le in label_encoders.items():
    X_train_no_date[col] = le.transform(X_train_no_date[col])

# Lista de modelos para validação cruzada
models = {
    'DummyClassifier': DummyClassifier(strategy='most_frequent'),
    'TimeSeriesForestClassifier': TimeSeriesForestClassifier(n_estimators=150, n_jobs=-1, random_state=42)
}

# Dicionário para armazenar os resultados
cv_results = {}

# Utilizando uma janela de 500 para o time series split
tscv = TimeSeriesSplit(max_train_size=500)

# Aplicando cross-validation para cada modelo
for model_name, model in models.items():
    pipeline = make_pipeline(
        ColumnConcatenator(),
        model)

    scores = cross_validate(pipeline, from_2d_array_to_nested(X_train_no_date), y_train_mapped, cv=tscv, scoring=['precision_weighted', 'accuracy', 'recall_weighted'], return_train_score=True, n_jobs=-1)
    cv_results[model_name] = scores
    print(f'{model_name} - Test Precision: {scores["test_precision_weighted"].mean():.4f} (+/- {scores["test_precision_weighted"].std():.4f})')
    print(f'{model_name} - Train Precision: {scores["train_precision_weighted"].mean():.4f} (+/- {scores["train_precision_weighted"].std():.4f})')

# Exibindo os resultados
cv_results

# Descompactar as listas no dicionário e criar um DataFrame
results_df = pd.DataFrame({model: {metric: scores for metric, scores in cv_results[model].items()} for model in cv_results})

# Exibir o DataFrame
results_df
# Calcular a média para cada métrica no dicionário
mean_results = {model: {metric: np.mean(scores) for metric, scores in cv_results[model].items()} for model in cv_results}

# Criar um DataFrame a partir dos resultados médios
results_df = pd.DataFrame(mean_results)

# Exibir o DataFrame
results_df.T

vendedores_ultimos_90 = df_pre_modelo_[df_pre_modelo_['date'] >= '2024-08-04'].seller_id.unique()
vendedores_ultimos_90

mask = [df_pre_modelo_[df_pre_modelo_['date'] < '2024-08-04'].isin(vendedores_ultimos_90).seller_id]
mask

mask = df_pre_modelo_[df_pre_modelo_['date'] < '2024-08-04']['seller_id'].isin(vendedores_ultimos_90)
df_pre_modelo_[df_pre_modelo_['date'] < '2024-08-04'][mask]

df_pre_modelo_v2 = pd.concat([df_pre_modelo_[df_pre_modelo_['date'] >= '2024-08-04'],
                              df_pre_modelo_[df_pre_modelo_['date'] < '2024-08-04'][mask]])

df_pre_modelo_v2