import pandas as pd
import dash
from dash import dcc, html
from dash.dependencies import Input, Output, State
import plotly.graph_objects as go
import os

# Traducción de las categorías
category_translation = {
    'MOLLUSCS': 'Moluscos',
    'CRUSTACEANS': 'Crustáceos',
    'FISHES': 'Peces',
    'OTHER': 'Otros',
    'ALGAE': 'Algas',
    'MAMMALS': 'Mamíferos'
}

# Cargar el dataset
df = pd.read_csv('/var/www/html/desembarques/DESEMBARQUESPESQUEROS_Artesanal_2002_2023.csv', encoding='utf-8', sep=",", low_memory=False)

# Convertir la columna 'año' a string y limpiar valores inconsistentes
df['año'] = df['año'].astype(str).str.extract(r'(\d{4})')
df = df[df['año'].notna()]
df['año'] = df['año'].astype(str)

# Agregar la columna 'Categoría' traducida
df['Categoría'] = df['Category'].map(category_translation)

# Definir el orden de las regiones (de norte a sur)
orden_regiones = [
    "Región de Arica y Parinacota", "Región de Tarapacá", "Región de Antofagasta",
    "Región de Atacama", "Región de Coquimbo", "Región de Valparaíso",
    "Región de O'Higgins", "Región de Maule", "Región de Ñuble",
    "Región de Bío-Bío", "Región de Araucanía", "Región de Los Ríos",
    "Región de Los Lagos", "Región de Aysén", "Región de Magallanes"
]

# Filtrar y ordenar las regiones presentes en el dataset
regiones = [r for r in orden_regiones if r in df['Región'].unique()]
especies = sorted(df['Especie'].unique())

# Asegurarse de que la carpeta 'data' existe
if not os.path.exists('/var/www/html/desembarques/data'):
    os.makedirs('/var/www/html/desembarques/data')

# Inicializar la app Dash
app = dash.Dash(__name__, requests_pathname_prefix='/desembarques/')
server = app.server

# Estructura de la app
app.layout = html.Div([
    html.Div([
        html.H1('Desembarques pesqueros artesanales (2002-2023)', style={'display': 'inline-block'}),
        html.Img(src='assets/DC_Logo.png', style={'height': '15%', 'width': '15%', 'margin-right': '20px'}),
        html.Img(src='assets/infografia-pesqueria-artesanal.png', style={'height': '10%', 'width': '10%'}),
    ], style={'display': 'flex', 'align-items': 'center', 'justify-content': 'center'}),

    dcc.Dropdown(
        id='especie-dropdown',
        options=[{'label': especie, 'value': especie} for especie in especies],
        value=especies[0],
        placeholder="Selecciona una especie"
    ),
    dcc.Dropdown(
        id='region-dropdown',
        options=[{'label': 'Total Nacional', 'value': 'Nacional'}] +
                [{'label': region, 'value': region} for region in regiones],
        value='Nacional',
        placeholder="Selecciona una región (Opcional)"
    ),
    html.Div([
        html.Label("Rango de años:"),
        dcc.Input(id='year-start', type='number', value=2002),
        dcc.Input(id='year-end', type='number', value=2023),
    ], style={'margin': '10px'}),

    dcc.Graph(id='especie-graph'),

    # Enlaces de descarga con un botón
    html.Div([
        html.Button("Descargar TODOS los datos para el rango de años", id="download-all-btn"),
        html.Button("Descargar datos filtrados", id="download-filtered-btn"),
    ], style={'text-align': 'center', 'margin-top': '20px'}),

    html.Div(id="download-status", style={'text-align': 'center', 'margin-top': '20px'}),

    html.Div([
        html.P("Fuente: SERNAPESCA - DataCenter SECOS"),
        html.P("Contacto: nico.segoviac@socioecologiacostera.cl"),
    ], style={'text-align': 'center', 'margin-top': '20px'}),
])

# Callback para actualizar el gráfico
@app.callback(
    Output('especie-graph', 'figure'),
    [Input('especie-dropdown', 'value'),
     Input('region-dropdown', 'value'),
     Input('year-start', 'value'),
     Input('year-end', 'value')]
)
def update_figure(selected_especie, selected_region, year_start, year_end):
    # Filtrar los datos por especie y el rango de años seleccionado
    df_filtered = df[(df['año'].astype(int) >= year_start) &
                     (df['año'].astype(int) <= year_end) &
                     (df['Especie'] == selected_especie)]

    if selected_region != 'Nacional':
        df_filtered = df_filtered[df_filtered['Región'] == selected_region]

    # Agrupar los datos por año y sumar los desembarques para el gráfico
    df_aggregated_for_plot = df_filtered.groupby('año')['Desembarque(Tons.)'].sum().reset_index()

    # Verificar si hay datos disponibles
    if df_aggregated_for_plot.empty:
        return go.Figure(
            layout=go.Layout(
                title="No hay datos disponibles para los filtros seleccionados",
                xaxis_title="Año",
                yaxis_title="Desembarques (Tons.)"
            )
        )

    # Obtener la comuna con más desembarques en el último año
    ultimo_anio = df_filtered['año'].astype(int).max()
    df_ultimo_anio = df_filtered[df_filtered['año'].astype(int) == ultimo_anio]
    top_comuna_ultimo_anio = df_ultimo_anio.groupby("Comuna")["Desembarque(Tons.)"].sum().reset_index().sort_values(by="Desembarque(Tons.)", ascending=False).iloc[0]
    comuna_ultimo_anio = top_comuna_ultimo_anio['Comuna']
    desembarque_ultimo_anio = top_comuna_ultimo_anio['Desembarque(Tons.)']
    region_ultimo_anio = df_ultimo_anio[df_ultimo_anio["Comuna"] == comuna_ultimo_anio]["Región"].iloc[0]

    # Obtener la comuna con más desembarque promedio en el rango de años
    df_comuna_avg = df_filtered.groupby("Comuna")["Desembarque(Tons.)"].mean().reset_index()
    top_comuna_promedio = df_comuna_avg.sort_values(by="Desembarque(Tons.)", ascending=False).iloc[0]
    comuna_promedio = top_comuna_promedio['Comuna']
    desembarque_promedio = top_comuna_promedio['Desembarque(Tons.)']
    region_promedio = df_filtered[df_filtered["Comuna"] == comuna_promedio]["Región"].iloc[0]

    # Obtener la desviación estándar de los desembarques por comuna
    df_comuna_std = df_filtered.groupby("Comuna")["Desembarque(Tons.)"].std().reset_index()
    std_promedio = df_comuna_std[df_comuna_std['Comuna'] == comuna_promedio]['Desembarque(Tons.)'].values[0]

    # Obtener el nombre científico y categoría
    spp_name = df_filtered["spp_scname"].iloc[0]
    categoria = df_filtered["Categoría"].iloc[0]

    # Crear el gráfico
    fig = go.Figure(data=[
        go.Scatter(
            x=df_aggregated_for_plot['año'],
            y=df_aggregated_for_plot['Desembarque(Tons.)'],
            mode='lines+markers',
            name='Desembarques',
            line=dict(color='#3D4F6C', width=3),
            marker=dict(color='#3D4F6C', size=10, symbol='circle')
        )
    ])

    # Agregar la información al gráfico
    fig.update_layout(
        title=f'Desembarques de {selected_especie} (<i>{spp_name}</i>): Categoría: {categoria}',
        xaxis_title='Año',
        yaxis_title='Desembarques (Tons.)',
        template='plotly_white',
        annotations=[
            dict(
                text=f"<b>Comuna con más desembarques el último año ({ultimo_anio})</b>: {comuna_ultimo_anio} ({region_ultimo_anio}) ({desembarque_ultimo_anio:.2f} tons)",
                xref="paper", yref="paper", x=1, y=1.1, showarrow=False,
                xanchor="right", yanchor="top", font=dict(size=12)
            ),
            dict(
                text=f"<b>Comuna con más desembarque promedio</b>: {comuna_promedio} ({region_promedio}) ({desembarque_promedio:.2f} ± {std_promedio:.2f} tons)",
                xref="paper", yref="paper", x=1, y=1.05, showarrow=False,
                xanchor="right", yanchor="top", font=dict(size=12)
            )
        ]
    )

    return fig

# Callback para generar los archivos CSV cuando se hace clic en los botones de descarga
@app.callback(
    Output('download-status', 'children'),
    [Input('download-all-btn', 'n_clicks'),
     Input('download-filtered-btn', 'n_clicks')],
    [State('especie-dropdown', 'value'),
     State('region-dropdown', 'value'),
     State('year-start', 'value'),
     State('year-end', 'value')]
)
def generate_csv(n_clicks_all, n_clicks_filtered, selected_especie, selected_region, year_start, year_end):
    ctx = dash.callback_context

    if not ctx.triggered:
        return ""
    
    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
    
    if button_id == 'download-all-btn':
        # Generar CSV con todos los datos
        filename_all = f"/var/www/html/desembarques/data/desembarques_todos_{year_start}_{year_end}.csv"
        df.to_csv(filename_all, index=False)
        return html.A("Descargar TODOS los datos", href=f"/{filename_all}", download=filename_all, target="_blank")
    
    elif button_id == 'download-filtered-btn':
        # Generar CSV con los datos filtrados
        df_filtered = df[(df['año'].astype(int) >= year_start) &
                         (df['año'].astype(int) <= year_end) &
                         (df['Especie'] == selected_especie)]

        if selected_region != 'Nacional':
            df_filtered = df_filtered[df_filtered['Región'] == selected_region]

        # Agregar por caleta y otras columnas
        df_aggregated_for_csv = df_filtered.groupby(
            ['año', 'CaletadeDesembarque', 'Región', 'Provincia', 'Comuna', 'Lat', 'Lon',
             'CódigoEspecie', 'ArtedePesca', 'Especie', 'spp_scname', 'Categoría']
        )['Desembarque(Tons.)'].sum().reset_index()

        filename_filtered = f"/var/www/html/desembarques/data/desembarques_{selected_region}_{selected_especie}_{year_start}_{year_end}.csv"
        df_aggregated_for_csv.to_csv(filename_filtered, index=False)

        return html.A(f"Descargar datos filtrados para {selected_region} y {selected_especie}",
                     href=f"/{filename_filtered}", download=filename_filtered, target="_blank")
    
    return ""

if __name__ == '__main__':
    app.run_server(debug=True)


"""
from dash import Dash, html, dcc
import dash

external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']

app = Dash(__name__, 
           external_stylesheets=external_stylesheets,
           use_pages=True,
           requests_pathname_prefix='/Dash/', pages_folder="")

server = app.server
app.scripts.config.serve_locally = True
app.css.config.serve_locally = True

app.layout = html.Div([
    html.H1('Multi-page app with Dash Pages'),

    html.Div(
        [
            html.Div(
                dcc.Link(
                    f"{page['name']} - {page['path']}", href=page["relative_path"]
                )
            )
            for page in dash.page_registry.values()
        ]
    ),

    dash.page_container
])

if __name__ == '__main__':
    app.run_server(debug=True)
"""