// overall-cli/src/server/mod.rs

use axum::{
    Router,
    routing::{get, post},
    extract::{Path, State},
    Json,
};
use tower_http::services::ServeDir;

pub async fn run_server(port: u16) -> Result<()> {
    let app = Router::new()
        // API routes
        .route("/api/build-info", get(build_info))
        .route("/api/groups", post(create_group))
        .route("/api/groups/:id/repos/:repo_id", post(move_repo_to_group))
        .route("/api/repos/create-pr", post(create_pull_request))
        .route("/api/repos/create-all-prs", post(create_all_pull_requests))
        .route("/api/local-repo-roots", post(add_local_repo_root))
        .route("/api/local-repos/scan", post(scan_local_repos))
        .route("/api/local-repos/status", get(get_local_repo_status))

        // Static file serving
        .nest_service("/", ServeDir::new("static"))

        // Shared state (database connection)
        .with_state(AppState { db: open_database()? });

    let addr = SocketAddr::from(([127, 0, 0, 1], port));
    println!("Server running on http://localhost:{}", port);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

pub struct ServerConfig {
    pub port: u16,              // Default: 8459
    pub static_dir: PathBuf,    // Default: ./static
    pub db_path: PathBuf,       // Default: ~/.overall/overall.db
    pub debug: bool,            // Default: false
}

async fn build_info() -> Json<BuildInfo> {
    Json(BuildInfo {
        version: env!("CARGO_PKG_VERSION").to_string(),
        commit: option_env!("GIT_COMMIT")
            .unwrap_or("unknown")
            .to_string(),
        build_date: option_env!("BUILD_DATE")
            .unwrap_or("unknown")
            .to_string(),
        wasm_build_date: include_str!("../../static/pkg/.build-date")
            .trim()
            .to_string(),
    })
}

#[derive(Deserialize)]
struct CreateGroupRequest {
    name: String,
}

async fn create_group(
    State(state): State<AppState>,
    Json(req): Json<CreateGroupRequest>,
) -> Result<Json<Group>, StatusCode> {
    if req.name.is_empty() {
        return Err(StatusCode::BAD_REQUEST);
    }

    let group = state.db.create_group(&req.name)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    // Trigger export to update repos.json
    export_to_json(&state.db)?;

    Ok(Json(group))
}

async fn move_repo_to_group(
    State(state): State<AppState>,
    Path((group_id, repo_id)): Path<(i64, String)>,
) -> Result<Json<SuccessResponse>, StatusCode> {
    // Verify group exists
    state.db.get_group(group_id)
        .map_err(|_| StatusCode::NOT_FOUND)?;

    // Verify repo exists
    state.db.get_repository(&repo_id)
        .map_err(|_| StatusCode::NOT_FOUND)?;

    // Move repo (removes from old group if any)
    state.db.move_repo_to_group(&repo_id, group_id)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    // Trigger export
    export_to_json(&state.db)?;

    Ok(Json(SuccessResponse {
        success: true,
        message: "Repository moved to group".to_string(),
    }))
}

#[derive(Deserialize)]
struct CreatePrRequest {
    owner: String,
    repo: String,
    branch: String,
    base: String,
    title: String,
    body: String,
}

async fn create_pull_request(
    State(state): State<AppState>,
    Json(req): Json<CreatePrRequest>,
) -> Result<Json<PrResponse>, StatusCode> {
    // Check if PR already exists
    let existing_pr = state.db
        .get_pr_for_branch(&format!("{}/{}", req.owner, req.repo), &req.branch)
        .ok();

    if existing_pr.is_some() {
        return Err(StatusCode::CONFLICT);
    }

    // Create PR via GitHub
    let pr = github::create_pull_request(&PrRequest {
        owner: req.owner,
        repo: req.repo,
        head: req.branch,
        base: req.base,
        title: req.title,
        body: req.body,
    })
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    // Save to database
    state.db.insert_pull_request(&pr)?;

    // Update branch status
    state.db.update_branch_status(&pr.branch_id, "PROpen")?;

    // Trigger export
    export_to_json(&state.db)?;

    Ok(Json(PrResponse {
        success: true,
        pr_number: pr.number,
        pr_url: pr.url,
    }))
}

async fn create_all_pull_requests(
    State(state): State<AppState>,
    Json(req): Json<CreateAllPrsRequest>,
) -> Result<Json<CreateAllPrsResponse>, StatusCode> {
    let base = req.base.unwrap_or_else(|| "main".to_string());

    // Find all branches ready for PR
    let ready_branches = state.db
        .get_branches_by_status("ReadyForPR")
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let mut created = vec![];
    let mut skipped = vec![];
    let mut failed = vec![];

    for branch in ready_branches {
        if req.dry_run.unwrap_or(false) {
            created.push(PrCreationResult {
                repo: branch.repo_id.clone(),
                branch: branch.name.clone(),
                pr_number: 0,
            });
            continue;
        }

        // Generate PR title and body
        let title = format!("Merge {} into {}", branch.name, base);
        let body = format!("Auto-generated PR for branch {}", branch.name);

        match github::create_pull_request(&PrRequest {
            owner: branch.owner,
            repo: branch.repo,
            head: branch.name.clone(),
            base: base.clone(),
            title,
            body,
        }) {
            Ok(pr) => {
                state.db.insert_pull_request(&pr)?;
                created.push(PrCreationResult {
                    repo: branch.repo_id,
                    branch: branch.name,
                    pr_number: pr.number,
                });
            }
            Err(e) => {
                failed.push(PrCreationFailure {
                    repo: branch.repo_id,
                    branch: branch.name,
                    error: e.to_string(),
                });
            }
        }
    }

    export_to_json(&state.db)?;

    Ok(Json(CreateAllPrsResponse {
        success: failed.is_empty(),
        created,
        skipped,
        failed,
    }))
}

#[derive(Serialize)]
struct ErrorResponse {
    error: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    details: Option<String>,
}

impl From<anyhow::Error> for ErrorResponse {
    fn from(err: anyhow::Error) -> Self {
        ErrorResponse {
            error: err.to_string(),
            details: err.chain()
                .skip(1)
                .map(|e| e.to_string())
                .collect::<Vec<_>>()
                .join(", ")
                .into(),
        }
    }
}

async fn handler(
    State(state): State<AppState>,
    Json(req): Json<Request>,
) -> Result<Json<Response>, (StatusCode, Json<ErrorResponse>)> {
    // Validate input
    if req.name.is_empty() {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(ErrorResponse {
                error: "Name is required".to_string(),
                details: None,
            }),
        ));
    }

    // Perform operation
    let result = state.db.operation(&req)
        .map_err(|e| (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse::from(e)),
        ))?;

    Ok(Json(result))
}

use tower_http::cors::CorsLayer;

let app = Router::new()
    .route(...)
    .layer(CorsLayer::permissive()); // Allow all origins (local dev only)

let app = Router::new()
    .route(...)
    .layer(
        CorsLayer::new()
            .allow_origin("https://app.example.com".parse::<HeaderValue>().unwrap())
            .allow_methods([Method::GET, Method::POST])
            .allow_headers([AUTHORIZATION, CONTENT_TYPE])
    )
    .layer(
        ServiceBuilder::new()
            .layer(HandleErrorLayer::new(|_: BoxError| async {
                StatusCode::INTERNAL_SERVER_ERROR
            }))
            .layer(TimeoutLayer::new(Duration::from_secs(30)))
            .layer(TraceLayer::new_for_http())
    );