use axum::routing::{get, post};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json, Router,
};
use axum_macros::debug_handler;

use crate::model::db::book::ActiveModel as BookActiveModel;
use crate::model::db::book::Column as BookColumn;
use crate::model::db::book::Model as BookModel;
use crate::model::db::prelude::Book;
use crate::model::http_body::book;
use crate::model::http_body::book::{BookInfo, BookItem};
use crate::model::http_body::common::SimpleResponse;
use crate::AppState;
use sea_orm::sqlx::types::chrono::Local;
use sea_orm::{entity::*, query::*};
use sea_orm::{ColumnTrait, Iden};

pub fn get_nest_handlers() -> Router<crate::AppState> {
    Router::new()
        .route(
            "/{id}",
            post(update_book_handler).get(get_book_by_id_handler),
        )
        .route("/", post(create_book_handler).get(get_all_books_handler))
}

// handlers
//
#[debug_handler]
async fn get_all_books_handler(
    state: State<AppState>
) -> Result<Json<Vec<book::BookItem>>,(StatusCode,String)> {
    // let conn = state.conn.get_postgres_connection_pool();
    let uid :i64 = 1;
    let all_books  = Book::find()
        .filter(BookColumn::Uid.eq(uid))
        .all(&state.conn)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR,e.to_string()))?;

    let mut books: Vec<BookItem> = Vec::new();
    for b in all_books {
        let book_resp = BookItem{
            id: b.id,
            name: b.name,
        };
        books.push(book_resp);
    }
    Ok(Json(books))
}

#[debug_handler]
async fn get_book_by_id_handler(
    Path(id):Path<i64>,
    state:State<AppState>,
) -> Result<Json<BookItem>,(StatusCode,String)> {
    // let conn = state.conn.get_postgres_connection_pool();
    let uid: i64 = 1;
    let book_query = Book::find()
        .filter(BookColumn::Uid.eq(uid))
        .filter(BookColumn::Id.eq(id))
        .one(&state.conn)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let book_resp: BookItem;
    match book_query {
        Some(b) => {
            book_resp = BookItem {
                id: b.id,
                name: b.name,
            };
        }
        _ => {
            return Err((StatusCode::NOT_FOUND, "not_found".to_string()));
        }
    }
    Ok(Json(book_resp))
}

#[debug_handler]
async fn create_book_handler(
    state: State<AppState>,
    Json(payload): Json<BookInfo>,
) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
    // let conn = state.conn.get_postgres_connection_pool();
    let uid: i64 = 1;

    let book = BookActiveModel {
        name: Set(payload.name.clone().to_owned()),
        uid: Set(uid.to_owned()),
        ..Default::default()
    };

    let res = Book::insert(book).exec(&state.conn).await;
    let mut err_code: i64 = 0;
    let mut msg: String;
    match res {
        Ok(_) => {
            err_code = 0;
            msg = "ok".to_owned();
        }
        Err(e) => {
            err_code = 0;
            msg = e.to_string();
        }
    }

    let resp = SimpleResponse {
        code: err_code,
        message: msg,
    };

    Ok(Json(resp))
}

#[debug_handler]
async fn update_book_handler(
    Path(id): Path<i64>,
    state: State<AppState>,
    Json(payload): Json<BookInfo>,
) -> Result<Json<SimpleResponse>, (StatusCode, String)> {
    // let conn = state.conn.get_postgres_connection_pool();
    let uid: i64 = 1;

    let exist_book = Book::find()
        .filter(BookColumn::Uid.eq(uid))
        .filter(BookColumn::Id.eq(id))
        .one(&state.conn)
        .await;
    let book: BookModel;
    let mut resp = SimpleResponse {
        code: 0,
        message: "ok".to_owned(),
    };
    match exist_book {
        Ok(b) => match b {
            Some(bk) => {
                book = bk;
            }
            _ => return Err((StatusCode::NOT_FOUND, "not_found".to_string())),
        },
        Err(_) => {
            resp.code = 1;
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                "connection_error".to_string(),
            ));
        }
    }

    let mut book_active_model: BookActiveModel = book.into();
    book_active_model.name = Set(payload.name.clone());
    book_active_model.updated_at = Set(Local::now().naive_utc());
    let update_res = book_active_model.update(&state.conn).await;
    match update_res {
        Ok(_) => {
            resp.code = 0;
            resp.message = "ok".to_owned();
        }
        Err(_) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                "book_update_fail".to_string(),
            ));
        }
    }
    Ok(Json(resp))
}