//! Integration tests for CLI action commands
#![allow(deprecated)]


use assert_cmd::Command;
use predicates::prelude::*;
use serde_json::json;
use wiremock::{
    matchers::{method, path},
    Mock, ResponseTemplate,
};

mod common;
use common::*;

#[tokio::test]
async fn test_action_list_authenticated() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action list endpoint
    mock_action_list(&fixture.mock_server).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("list");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("core.echo"))
        .stdout(predicate::str::contains("Echo a message"));
}

#[tokio::test]
async fn test_action_list_unauthenticated() {
    let fixture = TestFixture::new().await;
    fixture.write_default_config();

    // Mock unauthorized response
    mock_unauthorized(&fixture.mock_server, "/api/v1/actions").await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("list");

    cmd.assert().failure();
}

#[tokio::test]
async fn test_action_list_json_output() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action list endpoint
    mock_action_list(&fixture.mock_server).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("--json")
        .arg("action")
        .arg("list");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains(r#""ref""#))
        .stdout(predicate::str::contains(r#"core.echo"#));
}

#[tokio::test]
async fn test_action_list_yaml_output() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action list endpoint
    mock_action_list(&fixture.mock_server).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("--yaml")
        .arg("action")
        .arg("list");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("core.echo"))
        .stdout(predicate::str::contains("Echo a message"));
}

#[tokio::test]
async fn test_action_get_by_ref() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action get endpoint
    Mock::given(method("GET"))
        .and(path("/api/v1/actions/core.echo"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "id": 1,
                "ref": "core.echo",
                "pack": 1,
                "pack_ref": "core",
                "label": "Echo Action",
                "description": "Echo a message",
                "entrypoint": "echo.py",
                "runtime": null,
                "param_schema": {
                    "message": {
                        "type": "string",
                        "description": "Message to echo",
                        "required": true
                    }
                },
                "out_schema": null,
                "created": "2024-01-01T00:00:00Z",
                "updated": "2024-01-01T00:00:00Z"
            }
        })))
        .mount(&fixture.mock_server)
        .await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("show")
        .arg("core.echo");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("core.echo"))
        .stdout(predicate::str::contains("Echo a message"));
}

#[tokio::test]
async fn test_action_get_not_found() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock 404 response
    mock_not_found(&fixture.mock_server, "/api/v1/actions/nonexistent.action").await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("show")
        .arg("nonexistent.action");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("Error"));
}

#[tokio::test]
async fn test_action_execute_with_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 42).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--param")
        .arg("message=Hello World");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("42").or(predicate::str::contains("scheduled")));
}

#[tokio::test]
async fn test_action_execute_multiple_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 100).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("linux.run_command")
        .arg("--param")
        .arg("cmd=ls -la")
        .arg("--param")
        .arg("timeout=30");

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_execute_with_json_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 101).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.webhook")
        .arg("--params-json")
        .arg(r#"{"url": "https://example.com", "method": "POST"}"#);

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_execute_without_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 200).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.no_params_action");

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_execute_json_output() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 150).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("--json")
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--param")
        .arg("message=test");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("150"))
        .stdout(predicate::str::contains("scheduled"));
}

#[tokio::test]
async fn test_action_execute_wait_for_completion() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 250).await;

    // Mock execution polling - first running, then succeeded
    Mock::given(method("GET"))
        .and(path("/api/v1/executions/250"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "id": 250,
                "action": 1,
                "action_ref": "core.echo",
                "config": {"message": "test"},
                "parent": null,
                "enforcement": null,
                "executor": null,
                "status": "succeeded",
                "result": {"output": "test"},
                "created": "2024-01-01T00:00:00Z",
                "updated": "2024-01-01T00:00:00Z"
            }
        })))
        .mount(&fixture.mock_server)
        .await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--param")
        .arg("message=test")
        .arg("--wait");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("succeeded"));
}

#[tokio::test]
#[ignore = "Profile switching needs more investigation - CLI integration issue"]
async fn test_action_execute_with_profile() {
    let fixture = TestFixture::new().await;

    // Create multi-profile config
    let config = format!(
        r#"
current_profile: default
default_output_format: table
profiles:
  default:
    api_url: {}
    auth_token: default_token
    refresh_token: default_refresh
  production:
    api_url: {}
    auth_token: prod_token
    refresh_token: prod_refresh
"#,
        fixture.server_url(),
        fixture.server_url()
    );
    fixture.write_config(&config);

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 300).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--profile")
        .arg("production")
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--param")
        .arg("message=prod_test");

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_execute_invalid_param_format() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--param")
        .arg("invalid_format_no_equals");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("Error").or(predicate::str::contains("=")));
}

#[tokio::test]
async fn test_action_execute_invalid_json_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.echo")
        .arg("--params-json")
        .arg(r#"{"invalid json"#);

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("Error").or(predicate::str::contains("JSON")));
}

#[tokio::test]
async fn test_action_list_by_pack() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action list for a specific pack
    Mock::given(method("GET"))
        .and(path("/api/v1/packs/core/actions"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": [
                {
                    "id": 1,
                    "ref": "core.echo",
                    "pack_ref": "core",
                    "label": "Echo Action",
                    "description": "Echo a message",
                    "entrypoint": "echo.py",
                    "runtime": null,
                    "created": "2024-01-01T00:00:00Z",
                    "updated": "2024-01-01T00:00:00Z"
                }
            ],
            "meta": {
                "page": 1,
                "limit": 50,
                "total": 1,
                "total_pages": 1
            }
        })))
        .mount(&fixture.mock_server)
        .await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("list")
        .arg("--pack")
        .arg("core");

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_execute_async_flag() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action execute endpoint
    mock_action_execute(&fixture.mock_server, 400).await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("execute")
        .arg("core.long_running");
    // Note: default behavior is async (no --wait), so no --async flag needed

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("scheduled").or(predicate::str::contains("400")));
}

#[tokio::test]
async fn test_action_list_empty_result() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock empty action list
    Mock::given(method("GET"))
        .and(path("/api/v1/actions"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": []
        })))
        .mount(&fixture.mock_server)
        .await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("list");

    cmd.assert().success();
}

#[tokio::test]
async fn test_action_get_shows_parameters() {
    let fixture = TestFixture::new().await;
    fixture.write_authenticated_config("valid_token", "refresh_token");

    // Mock action get with detailed parameters
    Mock::given(method("GET"))
        .and(path("/api/v1/actions/core.complex"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "id": 5,
                "ref": "core.complex",
                "pack": 1,
                "pack_ref": "core",
                "label": "Complex Action",
                "description": "Complex action with multiple params",
                "entrypoint": "complex.py",
                "runtime": null,
                "param_schema": {
                    "required_string": {
                        "type": "string",
                        "description": "A required string parameter",
                        "required": true
                    },
                    "optional_number": {
                        "type": "integer",
                        "description": "An optional number",
                        "required": false,
                        "default": 42
                    },
                    "boolean_flag": {
                        "type": "boolean",
                        "description": "A boolean flag",
                        "required": false,
                        "default": false
                    }
                },
                "out_schema": null,
                "created": "2024-01-01T00:00:00Z",
                "updated": "2024-01-01T00:00:00Z"
            }
        })))
        .mount(&fixture.mock_server)
        .await;

    let mut cmd = Command::cargo_bin("attune").unwrap();
    cmd.env("XDG_CONFIG_HOME", fixture.config_dir_path())
        .env("HOME", fixture.config_dir_path())
        .arg("--api-url")
        .arg(fixture.server_url())
        .arg("action")
        .arg("show")
        .arg("core.complex");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("required_string"))
        .stdout(predicate::str::contains("optional_number"));
}