use crate::db;
use crate::types::{
    AvailableFiltersDto, Config, LandingDto, LookupDto, MonthlyAggregate,
    MonthlySpeciesBreakdown, PriceTrend, SpeciesDto, SummaryDto, TopSpecies,
};
use axum::{
    Json, Router,
    body::Body,
    extract::{Query, State},
    http::{HeaderValue, Method, StatusCode, header},
    response::{IntoResponse, Response},
    routing::get,
};
use rust_embed::Embed;
use serde::Deserialize;
use std::sync::Arc;
use tokio::sync::Mutex;
use tower_http::cors::{AllowOrigin, CorsLayer};
use tower_http::trace::TraceLayer;

#[derive(Clone)]
pub struct AppState {
    pub conn: Arc<Mutex<duckdb::Connection>>,
    #[allow(dead_code)]
    pub config: Arc<Config>,
}

#[derive(Embed)]
#[folder = "static/"]
struct StaticAssets;

#[derive(Debug, Clone, Deserialize)]
pub struct LandingsQuery {
    pub month: Option<String>,
    pub month_from: Option<String>,
    pub month_to: Option<String>,
    pub species: Option<String>,
    pub gear: Option<String>,
    pub zone: Option<String>,
    pub measure: Option<String>,
    #[serde(default = "default_limit")]
    pub limit: u32,
}

fn default_limit() -> u32 {
    10000
}

const MAX_LIMIT: u32 = 10000;

const LEAF_ONLY_FILTER: &str =
    "species_code != 'TOTAL' AND gear_code != 'TOTAL' AND zone_code != 'TOTAL'";

#[derive(Debug, Clone, Deserialize, Default)]
pub struct SummaryQuery {
    pub species: Option<String>,
    pub species_multi: Option<String>,
    pub month: Option<String>,
    pub month_from: Option<String>,
    pub month_to: Option<String>,
    pub zone: Option<String>,
    pub zone_multi: Option<String>,
    pub gear: Option<String>,
    pub gear_multi: Option<String>,
}

impl SummaryQuery {
    fn parse_multi(value: &Option<String>) -> Vec<String> {
        match value {
            Some(v) if !v.is_empty() => {
                v.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect()
            }
            _ => Vec::new(),
        }
    }

    fn build_conditions(&self) -> (Vec<String>, Vec<Box<dyn duckdb::ToSql>>) {
        let mut conditions: Vec<String> = Vec::new();
        let mut args: Vec<Box<dyn duckdb::ToSql>> = Vec::new();

        conditions.push(format!("({LEAF_ONLY_FILTER})"));

        if let Some(ref month) = self.month {
            conditions.push("month = ?".to_string());
            args.push(Box::new(month.clone()));
        }
        if let Some(ref month_from) = self.month_from {
            conditions.push("month >= ?".to_string());
            args.push(Box::new(month_from.clone()));
        }
        if let Some(ref month_to) = self.month_to {
            conditions.push("month <= ?".to_string());
            args.push(Box::new(month_to.clone()));
        }

        let species_list = Self::parse_multi(&self.species_multi);
        if !species_list.is_empty() {
            let placeholders: Vec<String> = (0..species_list.len())
                .map(|_| "?".to_string())
                .collect();
            conditions.push(format!("species_code IN ({})", placeholders.join(", ")));
            for s in &species_list {
                args.push(Box::new(s.clone()));
            }
        } else if let Some(ref species) = self.species {
            conditions.push("species_code = ?".to_string());
            args.push(Box::new(species.clone()));
        }

        let zone_list = Self::parse_multi(&self.zone_multi);
        if !zone_list.is_empty() {
            let placeholders: Vec<String> = (0..zone_list.len())
                .map(|_| "?".to_string())
                .collect();
            conditions.push(format!("zone_code IN ({})", placeholders.join(", ")));
            for z in &zone_list {
                args.push(Box::new(z.clone()));
            }
        } else if let Some(ref zone) = self.zone {
            conditions.push("zone_code = ?".to_string());
            args.push(Box::new(zone.clone()));
        }

        let gear_list = Self::parse_multi(&self.gear_multi);
        if !gear_list.is_empty() {
            let placeholders: Vec<String> = (0..gear_list.len())
                .map(|_| "?".to_string())
                .collect();
            conditions.push(format!("gear_code IN ({})", placeholders.join(", ")));
            for g in &gear_list {
                args.push(Box::new(g.clone()));
            }
        } else if let Some(ref gear) = self.gear {
            conditions.push("gear_code = ?".to_string());
            args.push(Box::new(gear.clone()));
        }

        (conditions, args)
    }

    fn build_where_and(&self) -> (String, Vec<Box<dyn duckdb::ToSql>>) {
        let (conditions, args) = self.build_conditions();
        let clause = if conditions.is_empty() {
            String::new()
        } else {
            format!(" AND {}", conditions.join(" AND "))
        };
        (clause, args)
    }

    fn build_where_prefix(&self) -> (String, Vec<Box<dyn duckdb::ToSql>>) {
        let (conditions, args) = self.build_conditions();
        let clause = if conditions.is_empty() {
            String::new()
        } else {
            format!(" WHERE {}", conditions.join(" AND "))
        };
        (clause, args)
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct AvailableFiltersQuery {
    pub month_from: Option<String>,
    pub month_to: Option<String>,
    pub species_multi: Option<String>,
    pub zone_multi: Option<String>,
    pub gear_multi: Option<String>,
}

impl AvailableFiltersQuery {
    fn parse_multi(value: &Option<String>) -> Vec<String> {
        match value {
            Some(v) if !v.is_empty() => {
                v.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect()
            }
            _ => Vec::new(),
        }
    }

    fn build_conditions_excluding(&self, exclude: &str) -> (Vec<String>, Vec<Box<dyn duckdb::ToSql>>) {
        let mut conditions: Vec<String> = Vec::new();
        let mut args: Vec<Box<dyn duckdb::ToSql>> = Vec::new();

        conditions.push(format!("({LEAF_ONLY_FILTER})"));

        if let Some(ref month_from) = self.month_from {
            conditions.push("month >= ?".to_string());
            args.push(Box::new(month_from.clone()));
        }
        if let Some(ref month_to) = self.month_to {
            conditions.push("month <= ?".to_string());
            args.push(Box::new(month_to.clone()));
        }

        if exclude != "species" {
            let species_list = Self::parse_multi(&self.species_multi);
            if !species_list.is_empty() {
                let placeholders: Vec<String> = species_list.iter().map(|_| "?".to_string()).collect();
                conditions.push(format!("species_code IN ({})", placeholders.join(", ")));
                for s in &species_list {
                    args.push(Box::new(s.clone()));
                }
            }
        }

        if exclude != "zone" {
            let zone_list = Self::parse_multi(&self.zone_multi);
            if !zone_list.is_empty() {
                let placeholders: Vec<String> = zone_list.iter().map(|_| "?".to_string()).collect();
                conditions.push(format!("zone_code IN ({})", placeholders.join(", ")));
                for z in &zone_list {
                    args.push(Box::new(z.clone()));
                }
            }
        }

        if exclude != "gear" {
            let gear_list = Self::parse_multi(&self.gear_multi);
            if !gear_list.is_empty() {
                let placeholders: Vec<String> = gear_list.iter().map(|_| "?".to_string()).collect();
                conditions.push(format!("gear_code IN ({})", placeholders.join(", ")));
                for g in &gear_list {
                    args.push(Box::new(g.clone()));
                }
            }
        }

        (conditions, args)
    }

    fn build_where_prefix_excluding(&self, exclude: &str) -> (String, Vec<Box<dyn duckdb::ToSql>>) {
        let (conditions, args) = self.build_conditions_excluding(exclude);
        let clause = if conditions.is_empty() {
            String::new()
        } else {
            format!(" WHERE {}", conditions.join(" AND "))
        };
        (clause, args)
    }
}

#[derive(Debug)]
pub struct ApiError {
    pub status: StatusCode,
    pub message: String,
}

impl IntoResponse for ApiError {
    fn into_response(self) -> Response {
        let body = serde_json::json!({ "error": self.message });
        (self.status, Json(body)).into_response()
    }
}

impl From<duckdb::Error> for ApiError {
    fn from(e: duckdb::Error) -> Self {
        tracing::error!("DuckDB error: {e}");
        ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Database error: {e}"),
        }
    }
}

impl From<db::DbError> for ApiError {
    fn from(e: db::DbError) -> Self {
        tracing::error!("DB error: {e}");
        ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Database error: {e}"),
        }
    }
}

type ApiResult<T> = std::result::Result<T, ApiError>;

pub fn build_router(state: AppState) -> Router {
    let cors = if state.config.allowed_origins.is_empty() {
        tracing::warn!("CORS is permissive — no allowed_origins configured");
        CorsLayer::permissive()
    } else {
        let origins: Vec<HeaderValue> = state
            .config
            .allowed_origins
            .iter()
            .filter_map(|s| s.parse().ok())
            .collect();

        if origins.len() < state.config.allowed_origins.len() {
            tracing::warn!(
                "{} origin(s) failed to parse (non-ASCII?): {:?}",
                state.config.allowed_origins.len() - origins.len(),
                state.config.allowed_origins
            );
        }

        if origins.is_empty() {
            tracing::warn!("No valid origins configured — falling back to permissive CORS");
            CorsLayer::permissive()
        } else {
            CorsLayer::new()
                .allow_methods([Method::GET])
                .allow_headers([header::CONTENT_TYPE])
                .allow_origin(AllowOrigin::list(origins))
        }
    };

    Router::new()
        .route("/healthz", get(healthz))
        .route("/api/species", get(get_species))
        .route("/api/zones", get(get_zones))
        .route("/api/gear", get(get_gear))
        .route("/api/available-filters", get(get_available_filters))
        .route("/api/landings", get(get_landings))
        .route("/api/summary", get(get_summary))
        .route("/api/summary/monthly-breakdown", get(get_monthly_breakdown))
        .route("/api/export.parquet", get(export_parquet))
        .fallback(static_handler)
        .layer(cors)
        .layer(TraceLayer::new_for_http())
        .with_state(state)
}

async fn healthz(State(_state): State<AppState>) -> impl IntoResponse {
    StatusCode::OK
}

async fn get_species(State(state): State<AppState>) -> ApiResult<Json<Vec<SpeciesDto>>> {
    let conn = state.conn.clone();
    let rows = tokio::task::spawn_blocking(move || -> db::Result<Vec<SpeciesDto>> {
        let conn = conn.blocking_lock();
        let mut stmt = conn.prepare("SELECT code, label FROM species WHERE code != 'TOTAL' ORDER BY code")?;
        let rows = stmt.query_map([], |row| {
            Ok(SpeciesDto {
                code: row.get(0)?,
                label: row.get(1)?,
            })
        })?;
        Ok(rows.collect::<std::result::Result<Vec<_>, duckdb::Error>>()?)
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(rows))
}

async fn get_landings(
    State(state): State<AppState>,
    Query(params): Query<LandingsQuery>,
) -> ApiResult<Json<Vec<LandingDto>>> {
    let conn = state.conn.clone();
    let capped_limit = std::cmp::min(params.limit, MAX_LIMIT);

    let rows = tokio::task::spawn_blocking(move || -> db::Result<Vec<LandingDto>> {
        let conn = conn.blocking_lock();

        let mut sql = String::from(
            "SELECT month, species_code, species_label, gear_code, zone_code, \
             processing_code, preservation_code, shipsize_code, measure_code, value \
             FROM landings WHERE 1=1 \
             AND species_code != 'TOTAL' AND gear_code != 'TOTAL' AND zone_code != 'TOTAL'",
        );
        let mut args: Vec<Box<dyn duckdb::ToSql>> = Vec::new();
        let mut idx = 1;

        if let Some(ref month) = params.month {
            sql.push_str(&format!(" AND month = ${idx}"));
            args.push(Box::new(month.clone()));
            idx += 1;
        }

        if let Some(ref month_from) = params.month_from {
            sql.push_str(&format!(" AND month >= ${idx}"));
            args.push(Box::new(month_from.clone()));
            idx += 1;
        }
        if let Some(ref month_to) = params.month_to {
            sql.push_str(&format!(" AND month <= ${idx}"));
            args.push(Box::new(month_to.clone()));
            idx += 1;
        }

        if let Some(ref species) = params.species {
            sql.push_str(&format!(" AND species_code = ${idx}"));
            args.push(Box::new(species.clone()));
            idx += 1;
        }
        if let Some(ref gear) = params.gear {
            sql.push_str(&format!(" AND gear_code = ${idx}"));
            args.push(Box::new(gear.clone()));
            idx += 1;
        }
        if let Some(ref zone) = params.zone {
            sql.push_str(&format!(" AND zone_code = ${idx}"));
            args.push(Box::new(zone.clone()));
            idx += 1;
        }
        if let Some(ref measure) = params.measure {
            sql.push_str(&format!(" AND measure_code = ${idx}"));
            args.push(Box::new(measure.clone()));
            idx += 1;
        }

        sql.push_str(&format!(
            " ORDER BY month, species_code, measure_code LIMIT ${idx}"
        ));
        args.push(Box::new(capped_limit as i64));

        let arg_refs: Vec<&dyn duckdb::ToSql> = args.iter().map(|b| b.as_ref()).collect();

        let mut stmt = conn.prepare(&sql)?;
        let rows = stmt.query_map(arg_refs.as_slice(), |row| {
            Ok(LandingDto {
                month: row.get(0)?,
                species_code: row.get(1)?,
                species_label: row.get(2)?,
                gear_code: row.get(3)?,
                zone_code: row.get(4)?,
                processing_code: row.get(5)?,
                preservation_code: row.get(6)?,
                shipsize_code: row.get(7)?,
                measure_code: row.get(8)?,
                value: row.get(9)?,
            })
        })?;

        Ok(rows.collect::<std::result::Result<Vec<_>, duckdb::Error>>()?)
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(rows))
}

async fn get_summary(
    State(state): State<AppState>,
    Query(params): Query<SummaryQuery>,
) -> ApiResult<Json<SummaryDto>> {
    let conn = state.conn.clone();

    let result = tokio::task::spawn_blocking(move || -> db::Result<SummaryDto> {
        let conn = conn.blocking_lock();

        let (where_clause, args) = params.build_where_and();

        let arg_refs: Vec<&dyn duckdb::ToSql> = args.iter().map(|b| b.as_ref()).collect();

        let monthly_sql = format!(
            "SELECT month, \
             SUM(CASE WHEN measure_code = 'MASS' THEN value END) AS total_mass, \
             SUM(CASE WHEN measure_code = 'VALUE' THEN value END) AS total_value \
             FROM landings WHERE 1=1{where_clause} \
             GROUP BY month ORDER BY month"
        );

        let mut stmt = conn.prepare(&monthly_sql)?;
        let monthly: Vec<MonthlyAggregate> = stmt
            .query_map(arg_refs.as_slice(), |row| {
                Ok(MonthlyAggregate {
                    month: row.get(0)?,
                    total_mass: row.get(1)?,
                    total_value: row.get(2)?,
                })
            })?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        let top_sql = format!(
            "SELECT species_code, \
             COALESCE(MAX(species_label), species_code) AS species_label, \
             SUM(CASE WHEN measure_code = 'VALUE' THEN value END) AS total_value, \
             SUM(CASE WHEN measure_code = 'MASS' THEN value END) AS total_mass \
             FROM landings WHERE 1=1{where_clause} \
             GROUP BY species_code, species_label \
             ORDER BY total_value DESC NULLS LAST \
             LIMIT 10"
        );

        let mut stmt = conn.prepare(&top_sql)?;
        let top_species: Vec<TopSpecies> = stmt
            .query_map(arg_refs.as_slice(), |row| {
                Ok(TopSpecies {
                    species_code: row.get(0)?,
                    species_label: row.get(1)?,
                    total_value: row.get(2)?,
                    total_mass: row.get(3)?,
                })
            })?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        let price_sql = format!(
            "WITH monthly_mass AS ( \
               SELECT month, SUM(value) AS mass FROM landings \
               WHERE measure_code = 'MASS'{where_clause} \
               GROUP BY month \
             ), \
             monthly_value AS ( \
               SELECT month, SUM(value) AS value FROM landings \
               WHERE measure_code = 'VALUE'{where_clause} \
               GROUP BY month \
             ) \
             SELECT m.month, \
                    CASE WHEN m.mass IS NOT NULL AND m.mass > 0 \
                         THEN v.value / m.mass END AS price_per_kg \
             FROM monthly_mass m \
             JOIN monthly_value v ON m.month = v.month \
             ORDER BY m.month"
        );

        let mut price_args: Vec<&dyn duckdb::ToSql> = Vec::with_capacity(args.len() * 2);
        for a in &args {
            price_args.push(a.as_ref());
        }
        for a in &args {
            price_args.push(a.as_ref());
        }

        let mut stmt = conn.prepare(&price_sql)?;
        let price_trend: Vec<PriceTrend> = stmt
            .query_map(price_args.as_slice(), |row| {
                Ok(PriceTrend {
                    month: row.get(0)?,
                    price_per_kg: row.get(1)?,
                })
            })?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        Ok(SummaryDto {
            monthly,
            top_species,
            price_trend,
        })
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(result))
}

async fn get_monthly_breakdown(
    State(state): State<AppState>,
    Query(params): Query<SummaryQuery>,
) -> ApiResult<Json<Vec<MonthlySpeciesBreakdown>>> {
    let conn = state.conn.clone();

    let result =
        tokio::task::spawn_blocking(move || -> db::Result<Vec<MonthlySpeciesBreakdown>> {
            let conn = conn.blocking_lock();

            let (where_clause, args) = params.build_where_prefix();

            let sql = format!(
                "SELECT month, species_code, MAX(species_label) as species_label, \
             SUM(CASE WHEN measure_code = 'VALUE' THEN value END) as total_value, \
             SUM(CASE WHEN measure_code = 'MASS' THEN value END) as total_mass \
             FROM landings{where_clause} \
             GROUP BY month, species_code \
             ORDER BY month ASC, total_value DESC NULLS LAST"
            );

            let arg_refs: Vec<&dyn duckdb::ToSql> = args.iter().map(|b| b.as_ref()).collect();

            let mut stmt = conn.prepare(&sql)?;
            let rows = stmt
                .query_map(arg_refs.as_slice(), |row| {
                    Ok(MonthlySpeciesBreakdown {
                        month: row.get(0)?,
                        species_code: row.get(1)?,
                        species_label: row.get(2)?,
                        total_value: row.get(3)?,
                        total_mass: row.get(4)?,
                    })
                })?
                .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

            Ok(rows)
        })
        .await
        .map_err(|e| ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Task join error: {e}"),
        })??;

    Ok(Json(result))
}

async fn get_available_filters(
    State(state): State<AppState>,
    Query(params): Query<AvailableFiltersQuery>,
) -> ApiResult<Json<AvailableFiltersDto>> {
    let conn = state.conn.clone();

    let result = tokio::task::spawn_blocking(move || -> db::Result<AvailableFiltersDto> {
        let conn = conn.blocking_lock();

        let (species_clause, species_args) = params.build_where_prefix_excluding("species");
        let species_arg_refs: Vec<&dyn duckdb::ToSql> = species_args.iter().map(|b| b.as_ref()).collect();

        let species_sql = if species_clause.is_empty() {
            "SELECT DISTINCT species_code FROM landings WHERE species_code != 'TOTAL' ORDER BY species_code"
        } else {
            "SELECT DISTINCT species_code FROM landings WHERE species_code != 'TOTAL'"
        };
        let species_sql = if species_clause.is_empty() {
            species_sql.to_string()
        } else {
            format!("SELECT DISTINCT species_code FROM landings{species_clause} AND species_code != 'TOTAL' ORDER BY species_code")
        };

        let mut stmt = conn.prepare(&species_sql)?;
        let species: Vec<String> = stmt
            .query_map(species_arg_refs.as_slice(), |row| row.get(0))?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        let (zone_clause, zone_args) = params.build_where_prefix_excluding("zone");
        let zone_arg_refs: Vec<&dyn duckdb::ToSql> = zone_args.iter().map(|b| b.as_ref()).collect();

        let zone_sql = if zone_clause.is_empty() {
            "SELECT DISTINCT zone_code FROM landings ORDER BY zone_code".to_string()
        } else {
            format!("SELECT DISTINCT zone_code FROM landings{zone_clause} ORDER BY zone_code")
        };

        let mut stmt = conn.prepare(&zone_sql)?;
        let zones: Vec<String> = stmt
            .query_map(zone_arg_refs.as_slice(), |row| row.get(0))?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        let (gear_clause, gear_args) = params.build_where_prefix_excluding("gear");
        let gear_arg_refs: Vec<&dyn duckdb::ToSql> = gear_args.iter().map(|b| b.as_ref()).collect();

        let gear_sql = if gear_clause.is_empty() {
            "SELECT DISTINCT gear_code FROM landings ORDER BY gear_code".to_string()
        } else {
            format!("SELECT DISTINCT gear_code FROM landings{gear_clause} ORDER BY gear_code")
        };

        let mut stmt = conn.prepare(&gear_sql)?;
        let gear: Vec<String> = stmt
            .query_map(gear_arg_refs.as_slice(), |row| row.get(0))?
            .collect::<std::result::Result<Vec<_>, duckdb::Error>>()?;

        Ok(AvailableFiltersDto {
            species,
            zones,
            gear,
        })
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(result))
}

async fn export_parquet(State(state): State<AppState>) -> ApiResult<Response> {
    let conn = state.conn.clone();

    let file_path = tokio::task::spawn_blocking(move || -> ApiResult<String> {
        let conn = conn.blocking_lock();

        let tmp = tempfile::Builder::new()
            .prefix("hagfish-")
            .suffix(".parquet")
            .tempfile()
            .map_err(|e| ApiError {
                status: StatusCode::INTERNAL_SERVER_ERROR,
                message: format!("Failed to create temp file: {e}"),
            })?;

        let (_kept_file, path) = tmp.keep().map_err(|e| ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Failed to persist temp file: {e}"),
        })?;

        let path_str = path
            .to_str()
            .ok_or_else(|| ApiError {
                status: StatusCode::INTERNAL_SERVER_ERROR,
                message: "Temp path contains invalid UTF-8".to_string(),
            })?
            .to_string();

        db::export_parquet(&conn, &path_str)?;

        drop(conn);

        Ok(path_str)
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    let file = tokio::fs::File::open(&file_path)
        .await
        .map_err(|e| ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Failed to open exported file: {e}"),
        })?;

    let stream = tokio_util::io::ReaderStream::new(file);
    let body = Body::from_stream(stream);

    let cleanup_path = file_path.clone();
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(300)).await;
        if let Err(e) = tokio::fs::remove_file(&cleanup_path).await {
            tracing::warn!("Failed to clean up parquet file {}: {e}", cleanup_path);
        }
    });

    Response::builder()
        .status(StatusCode::OK)
        .header(header::CONTENT_TYPE, "application/octet-stream")
        .header(
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"landings.parquet\"",
        )
        .body(body)
        .map_err(|e| ApiError {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message: format!("Failed to build response: {e}"),
        })
}

async fn static_handler(uri: axum::http::Uri) -> Response {
    let path = uri.path().trim_start_matches('/');

    let asset_path = if let Some(stripped) = path.strip_prefix("static/") {
        stripped
    } else {
        path
    };

    let asset_path = if asset_path.is_empty() {
        "index.html"
    } else {
        asset_path
    };

    let asset = StaticAssets::get(asset_path).or_else(|| StaticAssets::get("index.html"));

    match asset {
        Some(file) => {
            let mime = mime_guess::from_path(asset_path)
                .first_or_octet_stream()
                .as_ref()
                .to_string();

            Response::builder()
                .status(StatusCode::OK)
                .header(header::CONTENT_TYPE, mime)
                .body(Body::from(file.data.into_owned()))
                .unwrap_or_else(|_| {
                    Response::builder()
                        .status(StatusCode::INTERNAL_SERVER_ERROR)
                        .body(Body::from("Internal server error"))
                        .unwrap()
                })
        }
        None => Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(Body::from("Not found"))
            .unwrap(),
    }
}

async fn get_zones(State(state): State<AppState>) -> ApiResult<Json<Vec<LookupDto>>> {
    let conn = state.conn.clone();
    let rows = tokio::task::spawn_blocking(move || -> db::Result<Vec<LookupDto>> {
        let conn = conn.blocking_lock();
        let mut stmt = conn.prepare("SELECT code, label FROM zone WHERE code != 'TOTAL' ORDER BY code")?;
        let rows = stmt.query_map([], |row| {
            Ok(LookupDto {
                code: row.get(0)?,
                label: row.get(1)?,
            })
        })?;
        Ok(rows.collect::<std::result::Result<Vec<_>, duckdb::Error>>()?)
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(rows))
}

async fn get_gear(State(state): State<AppState>) -> ApiResult<Json<Vec<LookupDto>>> {
    let conn = state.conn.clone();
    let rows = tokio::task::spawn_blocking(move || -> db::Result<Vec<LookupDto>> {
        let conn = conn.blocking_lock();
        let mut stmt = conn.prepare("SELECT code, label FROM gear WHERE code != 'TOTAL' ORDER BY code")?;
        let rows = stmt.query_map([], |row| {
            Ok(LookupDto {
                code: row.get(0)?,
                label: row.get(1)?,
            })
        })?;
        Ok(rows.collect::<std::result::Result<Vec<_>, duckdb::Error>>()?)
    })
    .await
    .map_err(|e| ApiError {
        status: StatusCode::INTERNAL_SERVER_ERROR,
        message: format!("Task join error: {e}"),
    })??;

    Ok(Json(rows))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::Landing;
    use duckdb::Connection;
    use std::collections::HashMap;
    use std::collections::HashSet;

    fn test_state() -> AppState {
        let conn = Connection::open_in_memory().unwrap();
        db::init_schema(&conn).unwrap();

        let rows = vec![
            Landing {
                month: "2024M01".to_string(),
                species_code: "COD".to_string(),
                species_label: "Toskur".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "MASS".to_string(),
                value: Some(1000.0),
            },
            Landing {
                month: "2024M01".to_string(),
                species_code: "COD".to_string(),
                species_label: "Toskur".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "VALUE".to_string(),
                value: Some(5000.0),
            },
            Landing {
                month: "2024M01".to_string(),
                species_code: "HER".to_string(),
                species_label: "Sild".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "MASS".to_string(),
                value: Some(2000.0),
            },
            Landing {
                month: "2024M01".to_string(),
                species_code: "HER".to_string(),
                species_label: "Sild".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "VALUE".to_string(),
                value: Some(3000.0),
            },
            Landing {
                month: "2024M02".to_string(),
                species_code: "COD".to_string(),
                species_label: "Toskur".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "MASS".to_string(),
                value: Some(1500.0),
            },
            Landing {
                month: "2024M02".to_string(),
                species_code: "COD".to_string(),
                species_label: "Toskur".to_string(),
                gear_code: "TR1".to_string(),
                zone_code: "FO".to_string(),
                processing_code: "TOTAL".to_string(),
                preservation_code: "TOTAL".to_string(),
                shipsize_code: "TOTAL".to_string(),
                measure_code: "VALUE".to_string(),
                value: Some(7500.0),
            },
        ];

        db::update_lookups(
            &conn,
            &HashMap::from([(
                "Species (ASFIS2022)".to_string(),
                HashMap::from([
                    ("COD".to_string(), "Toskur".to_string()),
                    ("HER".to_string(), "Sild".to_string()),
                ]),
            )]),
        )
        .unwrap();

        db::upsert_landings(&conn, &rows).unwrap();

        AppState {
            conn: Arc::new(Mutex::new(conn)),
            config: Arc::new(Config {
                allowed_origins: vec!["https://hagfisk.poc.xn--fl-5ka.fo".to_string()],
                ..Default::default()
            }),
        }
    }

    fn empty_test_state() -> AppState {
        let conn = Connection::open_in_memory().unwrap();
        db::init_schema(&conn).unwrap();

        AppState {
            conn: Arc::new(Mutex::new(conn)),
            config: Arc::new(Config {
                allowed_origins: vec![],
                ..Default::default()
            }),
        }
    }

    async fn spawn_test_server(state: AppState) -> String {
        let app = build_router(state);
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();
        tokio::spawn(async move {
            axum::serve(listener, app).await.unwrap();
        });
        format!("http://{addr}")
    }

    #[tokio::test]
    async fn test_healthz_returns_ok() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/healthz")).await.unwrap();
        assert_eq!(resp.status(), StatusCode::OK);
    }

    #[tokio::test]
    async fn test_get_species_returns_all() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/species")).await.unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<SpeciesDto> = resp.json().await.unwrap();
        assert!(body.iter().any(|s| s.code == "COD" && s.label == "Toskur"));
        assert!(body.iter().any(|s| s.code == "HER" && s.label == "Sild"));
    }

    #[tokio::test]
    async fn test_get_landings_no_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings")).await.unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(!body.is_empty(), "Should have landing rows");
        assert_eq!(body.len(), 6);
    }

    #[tokio::test]
    async fn test_get_landings_filter_by_species() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings?species=COD"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(body.iter().all(|l| l.species_code == "COD"));
        assert_eq!(body.len(), 4);
    }

    #[tokio::test]
    async fn test_get_landings_filter_by_measure() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings?measure=MASS"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(body.iter().all(|l| l.measure_code == "MASS"));
        assert_eq!(body.len(), 3);
    }

    #[tokio::test]
    async fn test_get_landings_range_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!(
            "{base}/api/landings?month_from=2024M01&month_to=2024M01"
        ))
        .await
        .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(body.iter().all(|l| l.month == "2024M01"));
        assert_eq!(body.len(), 4);

        let resp = reqwest::get(format!(
            "{base}/api/landings?month_from=2024M01&month_to=2024M02"
        ))
        .await
        .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(!body.is_empty());
    }

    #[tokio::test]
    async fn test_get_summary_monthly_aggregates() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary")).await.unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();

        assert_eq!(body.monthly.len(), 2);

        let jan = body.monthly.iter().find(|m| m.month == "2024M01").unwrap();
        assert!((jan.total_mass.unwrap() - 3000.0).abs() < f64::EPSILON);
        assert!((jan.total_value.unwrap() - 8000.0).abs() < f64::EPSILON);

        let feb = body.monthly.iter().find(|m| m.month == "2024M02").unwrap();
        assert!((feb.total_mass.unwrap() - 1500.0).abs() < f64::EPSILON);
        assert!((feb.total_value.unwrap() - 7500.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn test_get_summary_top_species() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary")).await.unwrap();

        let body: SummaryDto = resp.json().await.unwrap();

        assert!(!body.top_species.is_empty());
        assert_eq!(body.top_species[0].species_code, "COD");
        assert!((body.top_species[0].total_value.unwrap() - 12500.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn test_get_summary_price_trend() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary")).await.unwrap();

        let body: SummaryDto = resp.json().await.unwrap();

        assert_eq!(body.price_trend.len(), 2);

        let jan = body
            .price_trend
            .iter()
            .find(|p| p.month == "2024M01")
            .unwrap();
        let expected_jan = 8000.0 / 3000.0;
        assert!((jan.price_per_kg.unwrap() - expected_jan).abs() < 0.01);

        let feb = body
            .price_trend
            .iter()
            .find(|p| p.month == "2024M02")
            .unwrap();
        assert!((feb.price_per_kg.unwrap() - 5.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn test_get_summary_with_species_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary?species=COD"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();

        assert_eq!(body.monthly.len(), 2);

        let jan = body.monthly.iter().find(|m| m.month == "2024M01").unwrap();
        assert!((jan.total_mass.unwrap() - 1000.0).abs() < f64::EPSILON);
        assert!((jan.total_value.unwrap() - 5000.0).abs() < f64::EPSILON);

        assert!(!body.top_species.is_empty());
        for ts in &body.top_species {
            assert_eq!(ts.species_code, "COD");
        }

        assert_eq!(body.price_trend.len(), 2);
        for pt in &body.price_trend {
            assert!(pt.price_per_kg.is_some());
        }
    }

    #[tokio::test]
    async fn test_get_summary_with_multi_species_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary?species_multi=COD,HER"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();
        assert_eq!(body.monthly.len(), 2);

        let jan = body.monthly.iter().find(|m| m.month == "2024M01").unwrap();
        assert!((jan.total_mass.unwrap() - 3000.0).abs() < f64::EPSILON);
        assert!((jan.total_value.unwrap() - 8000.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn test_get_summary_with_zone_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary?zone=FO"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();
        assert!(!body.monthly.is_empty());
    }

    #[tokio::test]
    async fn test_get_summary_with_gear_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary?gear=TR1"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();
        assert!(!body.monthly.is_empty());
    }

    #[tokio::test]
    async fn test_get_summary_with_month_range_filter() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!(
            "{base}/api/summary?month_from=2024M01&month_to=2024M01"
        ))
        .await
        .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();

        assert_eq!(body.monthly.len(), 1);
        assert_eq!(body.monthly[0].month, "2024M01");
    }

    #[tokio::test]
    async fn test_get_summary_with_combined_filters() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!(
            "{base}/api/summary?month_from=2024M01&month_to=2024M01&species=COD"
        ))
        .await
        .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: SummaryDto = resp.json().await.unwrap();

        assert_eq!(body.monthly.len(), 1);
        assert_eq!(body.monthly[0].month, "2024M01");
        assert!((body.monthly[0].total_mass.unwrap() - 1000.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn test_get_landings_faroese_label_preserved() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings?species=COD"))
            .await
            .unwrap();

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        let cod = &body[0];
        assert_eq!(cod.species_label, "Toskur");
        assert!(!cod.species_label.contains('\u{FFFD}'));
    }

    #[tokio::test]
    async fn test_get_landings_empty_result() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings?species=NONEXISTENT"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert!(body.is_empty());
    }

    #[tokio::test]
    async fn test_get_landings_limit_applied() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/landings?limit=2"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<LandingDto> = resp.json().await.unwrap();
        assert_eq!(body.len(), 2);
    }

    #[tokio::test]
    async fn test_export_parquet() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/export.parquet"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
            "attachment; filename=\"landings.parquet\""
        );

        let bytes = resp.bytes().await.unwrap();
        assert!(bytes.len() > 4);
        assert_eq!(&bytes[..4], b"PAR1");
    }

    #[tokio::test]
    async fn test_export_parquet_empty_db() {
        let state = empty_test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/export.parquet"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let bytes = resp.bytes().await.unwrap();
        assert_eq!(&bytes[..4], b"PAR1");
        assert!(bytes.len() > 4);
    }

    #[tokio::test]
    async fn test_concurrent_export_requests() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let url = format!("{base}/api/export.parquet");
        let (resp1, resp2) = tokio::join!(reqwest::get(&url), reqwest::get(&url));

        let resp1 = resp1.unwrap();
        let resp2 = resp2.unwrap();

        assert_eq!(resp1.status(), StatusCode::OK);
        assert_eq!(resp2.status(), StatusCode::OK);

        let bytes1 = resp1.bytes().await.unwrap();
        let bytes2 = resp2.bytes().await.unwrap();

        assert_eq!(&bytes1[..4], b"PAR1");
        assert_eq!(&bytes2[..4], b"PAR1");
        assert!(!bytes1.is_empty());
        assert!(!bytes2.is_empty());
    }

    #[tokio::test]
    async fn test_static_handler_falls_back_to_index_html() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/nonexistent-path-xyz"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body = resp.text().await.unwrap();
        assert!(body.contains("<html"));
        assert!(body.contains("<title>Fisheries Dashboard"));
    }

    #[tokio::test]
    async fn test_sql_injection_safe() {
        let state = test_state();
        let base = spawn_test_server(state.clone()).await;

        let malicious_params = "?species='; DROP TABLE landings; --";
        let url = format!("{base}/api/landings{malicious_params}");
        let resp = reqwest::get(&url).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);

        let count: i64 = tokio::task::spawn_blocking(move || {
            let conn = state.conn.blocking_lock();
            conn.query_row("SELECT COUNT(*) FROM landings", [], |row| row.get(0))
                .unwrap()
        })
        .await
        .unwrap();

        assert_eq!(count, 6);
    }

    #[tokio::test]
    async fn test_sql_injection_all_params_safe() {
        let state = test_state();
        let base = spawn_test_server(state.clone()).await;

        let malicious_params =
            "?month_from=2024M01'; DROP TABLE landings;--&month_to=2024M12&species=COD";
        let url = format!("{base}/api/landings{malicious_params}");
        let resp = reqwest::get(&url).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);

        let count: i64 = tokio::task::spawn_blocking(move || {
            let conn = state.conn.blocking_lock();
            conn.query_row("SELECT COUNT(*) FROM landings", [], |row| row.get(0))
                .unwrap()
        })
        .await
        .unwrap();

        assert_eq!(count, 6);
    }

    #[tokio::test]
    async fn test_get_monthly_breakdown_returns_species_by_month() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary/monthly-breakdown"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<MonthlySpeciesBreakdown> = resp.json().await.unwrap();
        assert!(!body.is_empty(), "Should have breakdown rows");

        let months: HashSet<_> = body.iter().map(|r| r.month.as_str()).collect();
        let species: HashSet<_> = body.iter().map(|r| r.species_code.as_str()).collect();

        assert!(!months.is_empty());
        assert!(!species.is_empty());

        for row in &body {
            assert!(!row.species_code.is_empty());
            assert!(!row.species_label.is_empty());
            assert!(row.total_value.is_some() || row.total_mass.is_some());
        }
    }

    #[tokio::test]
    async fn test_get_monthly_breakdown_filtered_by_month_range() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!(
            "{base}/api/summary/monthly-breakdown?month_from=2024M01&month_to=2024M01"
        ))
        .await
        .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<MonthlySpeciesBreakdown> = resp.json().await.unwrap();

        for row in &body {
            assert_eq!(row.month, "2024M01");
        }
    }

    #[tokio::test]
    async fn test_get_monthly_breakdown_filtered_by_species() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/summary/monthly-breakdown?species=COD"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: Vec<MonthlySpeciesBreakdown> = resp.json().await.unwrap();

        for row in &body {
            assert_eq!(row.species_code, "COD");
            assert_eq!(row.species_label, "Toskur");
        }
    }

    #[tokio::test]
    async fn test_get_available_filters_no_constraints() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/available-filters"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: AvailableFiltersDto = resp.json().await.unwrap();
        assert!(body.species.contains(&"COD".to_string()));
        assert!(body.zones.contains(&"FO".to_string()));
        assert!(body.gear.contains(&"TR1".to_string()));
    }

    #[tokio::test]
    async fn test_get_available_filters_with_species_constraint() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/available-filters?species_multi=COD"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: AvailableFiltersDto = resp.json().await.unwrap();
        assert!(body.species.contains(&"COD".to_string()));
        assert!(body.zones.contains(&"FO".to_string()));
        assert!(body.gear.contains(&"TR1".to_string()));
    }

    #[tokio::test]
    async fn test_get_available_filters_excludes_unrelated_species() {
        let state = test_state();
        let base = spawn_test_server(state).await;

        let resp = reqwest::get(format!("{base}/api/available-filters?zone_multi=FO"))
            .await
            .unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let body: AvailableFiltersDto = resp.json().await.unwrap();
        assert!(body.species.contains(&"COD".to_string()));
        assert!(body.species.contains(&"HER".to_string()));
    }
}