use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    Json,
};
use sea_orm::{
    ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, ModelTrait, PaginatorTrait, QueryFilter,
    QueryOrder, Set,
};
use serde::Deserialize;
use chrono::Utc;

use crate::{
    models::{
        permission::{self, CreatePermissionRequest, UpdatePermissionRequest, PermissionResponse},
        ApiResponse, PageResponse,
    },
};

#[derive(Debug, Deserialize)]
pub struct PermissionQuery {
    pub page: Option<u64>,
    pub page_size: Option<u64>,
    pub name: Option<String>,
    pub resource: Option<String>,
    pub action: Option<String>,
    pub status: Option<i8>,
}

pub async fn get_permissions(
    State(db): State<DatabaseConnection>,
    Query(params): Query<PermissionQuery>,
) -> Result<Json<ApiResponse<PageResponse<PermissionResponse>>>, StatusCode> {
    let page = params.page.unwrap_or(1);
    let page_size = params.page_size.unwrap_or(10);
    
    let mut query = permission::Entity::find();
    
    // 添加过滤条件
    if let Some(name) = params.name {
        query = query.filter(permission::Column::Name.contains(&name));
    }
    if let Some(resource) = params.resource {
        query = query.filter(permission::Column::Resource.contains(&resource));
    }
    if let Some(action) = params.action {
        query = query.filter(permission::Column::Action.contains(&action));
    }
    if let Some(status) = params.status {
        query = query.filter(permission::Column::Status.eq(status));
    }
    
    // 获取总数
    let total = query
        .clone()
        .count(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    // 分页查询
    let permissions = query
        .order_by_desc(permission::Column::CreatedAt)
        .paginate(&db, page_size)
        .fetch_page(page - 1)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    let permission_responses: Vec<PermissionResponse> = permissions
        .into_iter()
        .map(|p| PermissionResponse {
            id: p.id,
            name: p.name,
            key: p.key,
            description: p.description,
            resource: p.resource,
            action: p.action,
            status: p.status,
            created_at: p.created_at,
            updated_at: p.updated_at,
        })
        .collect();
    
    let page_response = PageResponse::new(permission_responses, total, page, page_size);
    Ok(Json(ApiResponse::success(page_response)))
}

pub async fn get_all_permissions(
    State(db): State<DatabaseConnection>,
) -> Result<Json<ApiResponse<Vec<PermissionResponse>>>, StatusCode> {
    let permissions = permission::Entity::find()
        .filter(permission::Column::Status.eq(1))
        .order_by_asc(permission::Column::Resource)
        .order_by_asc(permission::Column::Action)
        .all(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    let permission_responses: Vec<PermissionResponse> = permissions
        .into_iter()
        .map(|p| PermissionResponse {
            id: p.id,
            name: p.name,
            key: p.key,
            description: p.description,
            resource: p.resource,
            action: p.action,
            status: p.status,
            created_at: p.created_at,
            updated_at: p.updated_at,
        })
        .collect();
    
    Ok(Json(ApiResponse::success(permission_responses)))
}

pub async fn create_permission(
    State(db): State<DatabaseConnection>,
    Json(payload): Json<CreatePermissionRequest>,
) -> Result<Json<ApiResponse<PermissionResponse>>, StatusCode> {
    // 检查权限键是否已存在
    let existing_permission = permission::Entity::find()
        .filter(permission::Column::Key.eq(&payload.key))
        .one(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    if existing_permission.is_some() {
        return Ok(Json(ApiResponse::error(
            400,
            "权限键已存在".to_string(),
        )));
    }
    
    // 创建权限
    let now = Utc::now();
    let new_permission = permission::ActiveModel {
        name: Set(payload.name),
        key: Set(payload.key),
        description: Set(payload.description),
        resource: Set(payload.resource),
        action: Set(payload.action),
        status: Set(1),
        created_at: Set(now),
        updated_at: Set(now),
        ..Default::default()
    };
    
    let permission = new_permission
        .insert(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    let permission_response = PermissionResponse {
        id: permission.id,
        name: permission.name,
        key: permission.key,
        description: permission.description,
        resource: permission.resource,
        action: permission.action,
        status: permission.status,
        created_at: permission.created_at,
        updated_at: permission.updated_at,
    };
    
    Ok(Json(ApiResponse::success(permission_response)))
}

pub async fn update_permission(
    State(db): State<DatabaseConnection>,
    Path(id): Path<i32>,
    Json(payload): Json<UpdatePermissionRequest>,
) -> Result<Json<ApiResponse<PermissionResponse>>, StatusCode> {
    // 查找权限
    let permission = permission::Entity::find_by_id(id)
        .one(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    let permission = match permission {
        Some(permission) => permission,
        None => {
            return Ok(Json(ApiResponse::error(
                404,
                "权限不存在".to_string(),
            )))
        }
    };
    
    // 如果更新权限键，检查是否已存在
    if let Some(ref key) = payload.key {
        if key != &permission.key {
            let existing_permission = permission::Entity::find()
                .filter(permission::Column::Key.eq(key))
                .one(&db)
                .await
                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
            
            if existing_permission.is_some() {
                return Ok(Json(ApiResponse::error(
                    400,
                    "权限键已存在".to_string(),
                )));
            }
        }
    }
    
    let mut permission: permission::ActiveModel = permission.into();
    
    // 更新字段
    if let Some(name) = payload.name {
        permission.name = Set(name);
    }
    if let Some(key) = payload.key {
        permission.key = Set(key);
    }
    if let Some(description) = payload.description {
        permission.description = Set(Some(description));
    }
    if let Some(resource) = payload.resource {
        permission.resource = Set(resource);
    }
    if let Some(action) = payload.action {
        permission.action = Set(action);
    }
    if let Some(status) = payload.status {
        permission.status = Set(status);
    }
    permission.updated_at = Set(Utc::now());
    
    let updated_permission = permission
        .update(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    let permission_response = PermissionResponse {
        id: updated_permission.id,
        name: updated_permission.name,
        key: updated_permission.key,
        description: updated_permission.description,
        resource: updated_permission.resource,
        action: updated_permission.action,
        status: updated_permission.status,
        created_at: updated_permission.created_at,
        updated_at: updated_permission.updated_at,
    };
    
    Ok(Json(ApiResponse::success(permission_response)))
}

pub async fn delete_permission(
    State(db): State<DatabaseConnection>,
    Path(id): Path<i32>,
) -> Result<Json<ApiResponse<()>>, StatusCode> {
    // 查找权限
    let permission = permission::Entity::find_by_id(id)
        .one(&db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    
    match permission {
        Some(permission) => {
            // 删除权限（级联删除会自动处理关联表）
            permission
                .delete(&db)
                .await
                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
            
            Ok(Json(ApiResponse::success(())))
        }
        None => Ok(Json(ApiResponse::error(
            404,
            "权限不存在".to_string(),
        ))),
    }
}