[package]
name = "outro_08"
version = "0.1.0"
edition = "2021"

[dependencies]
thiserror = "1.0.61"
tokio = { version = "1", features = ["full"] }
ticket_fields = { path = "../../../helpers/ticket_fields" }
anyhow = "1.0.86"
chrono = { version = "0.4.38", features = ["now", "serde"] }
serde = { version = "1.0.204", features = ["derive"] }
sqlx = { version = "0.7.4", features = [
 "sqlite",
 "runtime-tokio-native-tls",
 "chrono",
 "uuid",
] }
uuid = { version = "1.9.1", features = ["v7", "serde"] }
shaku = { version = "0.6.1", features = ["derive"] }
async-trait = "0.1.81"
axum = "0.7.5"
serde_json = "1.0.120"
dotenvy = "0.15.7"
derive_more = "0.99.18"
http = "1.1.0"

use crate::db::{SqliteImpl, SqliteImplParameters};
use crate::store::StoreImpl;
use anyhow::anyhow;
use anyhow::Result;
use axum::routing::{get, post};
use axum::Router;
use shaku::module;
use sqlx::sqlite::SqlitePool;
use std::sync::Arc;
use tokio::net::TcpListener;

mod end_points;
use end_points::{create_ticket, get_all_ticket, get_ticket_by_id, update_ticket};

module! {
 StoreModule {
 // 今回必要な具象をここに記述
 // impl Store for StoreImplである
 // StoreImplはimpl Dbな何某を必要とする
 // impl Db for SqliteImplである
 components = [StoreImpl, SqliteImpl],
 providers = []
 }
}

pub struct Config {
 pub database_url: String,
}

pub async fn serve(Config { database_url }: Config) -> Result<()> {
 let pool = SqlitePool::connect(&database_url)
 .await
 .map_err(|e| anyhow!("[@{} in {}] {:?}", line!(), file!(), e))?;

 // StoreModuleを作成
 let store = StoreModule::builder()
 .with_component_parameters::<SqliteImpl>(SqliteImplParameters { pool })
 .build();

 // エンドポイントを定義
 // エンドポイントに対して、対応する処理には関数を指定
 let app = Router::new()
 .route("/tickets", get(get_all_ticket))
 .route("/tickets/id/:ticket_id", get(get_ticket_by_id))
 .route("/tickets/create", post(create_ticket))
 .route("/tickets/update", post(update_ticket))
 .with_state(Arc::new(store));

 // 3000番ポートで待ち受けることにする
 let listener = TcpListener::bind("0.0.0.0:3000")
 .await
 .map_err(|e| anyhow!("[@{} in {}] {:?}", line!(), file!(), e))?;

 // ループ実行
 axum::serve(listener, app)
 .await
 .map_err(|e| anyhow!("[@{} in {}] {:?}", line!(), file!(), e))?;

 Ok(())
}

use super::StoreModule;
use crate::data::{TicketDraftDto, TicketDto, TicketId, TicketPatchDto};
use crate::store::Store;
use crate::store::UpdateResult;
use axum::extract::{Json, Path, State};
use axum::response::{IntoResponse, Result};
use http::status::StatusCode;
use shaku::HasComponent;
use std::sync::Arc;
use uuid::Uuid;

#[allow(unused)]
pub async fn get_ticket_by_id(
 State(module): State<Arc<StoreModule>>,
 Path(ticket_id): Path<Uuid>,
) -> Result<Json<TicketDto>> {
 let store: &dyn Store = module.resolve_ref();

 let ticket = store.get(TicketId(ticket_id)).await?;

 match ticket {
 Some(t) => Ok(Json(t.into())),
 None => Err(StatusCode::NOT_FOUND.into()),
 }
}

#[allow(unused)]
pub async fn get_all_ticket(
 State(module): State<Arc<StoreModule>>,
) -> Result<Json<Vec<TicketDto>>> {
 let store: &dyn Store = module.resolve_ref();

 let tickets = store.get_all().await?;

 Ok(Json(tickets.into_iter().map(TicketDto::from).collect()))
}

#[allow(unused)]
pub async fn create_ticket(
 State(module): State<Arc<StoreModule>>,
 Json(draft): Json<TicketDraftDto>,
) -> Result<Json<Uuid>> {
 let store: &dyn Store = module.resolve_ref();

 let draft = draft.try_into().map_err(|e| {
 (StatusCode::BAD_REQUEST, format!("Invalid Format: {:?}", e)).into_response()
 })?;

 let id = store.add_ticket(draft).await?;

 Ok(Json(id.0))
}

#[allow(unused)]
pub async fn update_ticket(
 State(module): State<Arc<StoreModule>>,
 Json(patch): Json<TicketPatchDto>,
) -> Result<Json<UpdateResult<TicketPatchDto, TicketDto>>> {
 let store: &dyn Store = module.resolve_ref();

 let patch = patch.try_into().map_err(|e| {
 (StatusCode::BAD_REQUEST, format!("Invalid Format: {:?}", e)).into_response()
 })?;

 let update_result = store.update(patch).await?.into_dto();

 Ok(Json(update_result))
}

#[async_trait]
pub trait Store: Interface {
 async fn add_ticket(&self, ticket: TicketDraft) -> Result<TicketId, StoreError>;

 async fn get(&self, id: TicketId) -> Result<Option<Ticket>, StoreError>;

 async fn get_all(&self) -> Result<Vec<Ticket>, StoreError>;

 async fn update(
 &self,
 patch: TicketPatch,
 ) -> Result<UpdateResult<TicketPatch, Ticket>, StoreError>;
}

#[derive(Component)]
#[shaku(interface = Store)]
pub struct StoreImpl {
 #[shaku(inject)]
 db: Arc<dyn Db>,
 #[shaku(default)]
 cache: Mutex<BTreeMap<TicketId, Ticket>>,
}

#[async_trait]
impl Store for StoreImpl {
 async fn add_ticket(&self, ticket: TicketDraft) -> Result<TicketId, StoreError> {
 //...
 }
 //...
}