use admin_api::service::{OpenApiImportCreatePayload, OpenApiImportPreviewPayload};
use crank_core::WorkspaceId;
use serial_test::serial;

use super::common::{
    test_auth_settings, test_registry, test_secret_crypto, test_service, test_storage_root,
};

const OPENAPI3: &str = r#"
openapi: 3.0.3
info:
  title: Frankfurter API
servers:
  - url: https://api.frankfurter.dev
paths:
  /v2/latest:
    get:
      operationId: latestRates
      summary: Получить последние курсы валют
      description: Курсы.
      tags: [currency]
      parameters:
        - name: base
          in: query
          required: true
          schema: { type: string }
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
                properties:
                  base: { type: string }
                  rates:
                    type: object
"#;

#[tokio::test]
#[serial]
async fn previews_openapi_and_creates_draft_operations() {
    let registry = test_registry().await;
    let service = test_service(
        registry,
        test_storage_root("openapi_import"),
        test_auth_settings(),
        test_secret_crypto(),
    );
    let workspace_id = WorkspaceId::new("ws_default");

    let preview = service
        .preview_openapi_import(
            &workspace_id,
            OpenApiImportPreviewPayload {
                document: OPENAPI3.to_owned(),
            },
        )
        .await
        .unwrap();

    assert_eq!(preview.preview.groups.len(), 1);
    assert_eq!(
        preview.preview.groups[0].operations[0].suggested_name,
        "latest_rates"
    );

    let created = service
        .create_openapi_import(
            &workspace_id,
            &preview.job_id.as_str().into(),
            OpenApiImportCreatePayload {
                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
                server_url: Some("https://api.frankfurter.dev".to_owned()),
                conflict_mode: "skip".to_owned(),
            },
        )
        .await
        .unwrap();

    assert_eq!(created.created.len(), 1);
    assert_eq!(created.created[0].name, "latest_rates");
    assert!(created.skipped.is_empty());

    let operations = service.list_operations(&workspace_id).await.unwrap();
    assert!(
        operations
            .iter()
            .any(|operation| operation.name == "latest_rates")
    );
    let imported = operations
        .iter()
        .find(|operation| operation.name == "latest_rates")
        .unwrap();
    let version = service
        .get_operation_version(
            &workspace_id,
            &imported.id.as_str().into(),
            imported.current_draft_version,
        )
        .await
        .unwrap();
    let import_findings = &version
        .snapshot
        .wizard_state
        .as_ref()
        .unwrap()
        .import_findings;
    assert!(
        import_findings
            .iter()
            .any(|finding| finding.code == "openapi_import.weak_tool_description")
    );

    let skipped = service
        .create_openapi_import(
            &workspace_id,
            &preview.job_id.as_str().into(),
            OpenApiImportCreatePayload {
                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
                server_url: Some("https://api.frankfurter.dev".to_owned()),
                conflict_mode: "skip".to_owned(),
            },
        )
        .await
        .unwrap();

    assert!(skipped.created.is_empty());
    assert_eq!(skipped.skipped.len(), 1);
    assert_eq!(skipped.skipped[0].name, "latest_rates");
    assert_eq!(skipped.findings[0].code, "operation_name_conflict");

    let renamed = service
        .create_openapi_import(
            &workspace_id,
            &preview.job_id.as_str().into(),
            OpenApiImportCreatePayload {
                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
                server_url: Some("https://api.frankfurter.dev".to_owned()),
                conflict_mode: "rename".to_owned(),
            },
        )
        .await
        .unwrap();

    assert_eq!(renamed.created.len(), 1);
    assert_eq!(renamed.created[0].name, "latest_rates_2");
    assert_eq!(renamed.findings[0].code, "operation_name_renamed");
}