/*
 * This file is part of laurelin/api
 * Copyright (C) 2023 Jonni Liljamo <jonni@liljamo.com>
 *
 * Licensed under GPL-3.0-only.
 * See LICENSE for licensing information.
 */

use actix_session::Session;
use actix_web::{get, post, web, HttpResponse, Responder};
use laurelin_shared::error::api::APIError;

use crate::{actions, session, PgPool};

#[post("/api/game")]
async fn create(session: Session, pool: web::Data<PgPool>) -> impl Responder {
    let session_validation = session::validate_session(&session);

    match session_validation {
        Err(err) => err,
        Ok(user_id) => {
            let game_create = web::block(move || {
                let mut conn = match pool.get() {
                    Err(_) => return Err(APIError::DatabasePoolGetFailed),
                    Ok(conn) => conn,
                };
                actions::game::create(&mut conn, &user_id)
            })
            .await;
            match game_create {
                Err(_err) => HttpResponse::InternalServerError().json(APIError::Undefined),
                Ok(game_res) => match game_res {
                    Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
                    Ok(game) => HttpResponse::Ok().json(game),
                },
            }
        }
    }
}

#[get("/api/game/{id}")]
async fn info(
    session: Session,
    _pool: web::Data<PgPool>,
    _id: web::Path<String>,
) -> impl Responder {
    let session_validation = session::validate_session(&session);

    match session_validation {
        Err(err) => err,
        Ok(_user_id) => {
            //
            HttpResponse::Ok().body("INFO")
        }
    }
}

#[post("/api/game/{id}/join")]
async fn join(
    session: Session,
    _pool: web::Data<PgPool>,
    _id: web::Path<String>,
) -> impl Responder {
    let session_validation = session::validate_session(&session);

    match session_validation {
        Err(err) => err,
        Ok(_user_id) => {
            //
            HttpResponse::Ok().body("JOIN")
        }
    }
}

#[get("/api/game/all_forming")]
async fn all_forming(session: Session, pool: web::Data<PgPool>) -> impl Responder {
    let session_validation = session::validate_session(&session);

    match session_validation {
        Err(err) => err,
        Ok(_user_id) => {
            let all_forming = web::block(move || {
                let mut conn = match pool.get() {
                    Err(_) => return Err(APIError::DatabasePoolGetFailed),
                    Ok(conn) => conn,
                };
                actions::game::all_forming(&mut conn)
            })
            .await;
            match all_forming {
                Err(_err) => HttpResponse::InternalServerError().json(APIError::Undefined),
                Ok(games_res) => match games_res {
                    Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
                    Ok(games) => HttpResponse::Ok().json(games),
                },
            }
        }
    }
}

#[get("/api/game/my_games")]
async fn my_games(session: Session, pool: web::Data<PgPool>) -> impl Responder {
    let session_validation = session::validate_session(&session);

    match session_validation {
        Err(err) => err,
        Ok(user_id) => {
            let my_games = web::block(move || {
                let mut conn = match pool.get() {
                    Err(_) => return Err(APIError::DatabasePoolGetFailed),
                    Ok(conn) => conn,
                };
                actions::game::my_games(&mut conn, &user_id)
            })
            .await;
            match my_games {
                Err(_err) => HttpResponse::InternalServerError().json(APIError::Undefined),
                Ok(games_res) => match games_res {
                    Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
                    Ok(games) => HttpResponse::Ok().json(games),
                },
            }
        }
    }
}