use cosmicus::{
  run_workflow,
  runner::{CreateWorkflowOptions, Secret, WorkflowAPIEvent, WorkflowEvent, WorkflowMessage},
  CosmicusServer, RunWorkflowConfig, ServerPlugin,
};
use std::{env, fs, sync::Mutex};

const WORKFLOW: &str = r#"
name: test

jobs:
  test-job:
    name: test
    runs-on: ubuntu-latest
    steps:
      - name: test
        secrets:
          - test_secret
        run: |
          echo "test $TEST_SECRET"
"#;

struct MyPlugin {
  server: Mutex<Option<CosmicusServer>>,
}

impl MyPlugin {
  fn new() -> Self {
    MyPlugin {
      server: Mutex::new(None),
    }
  }
}

impl ServerPlugin for MyPlugin {
  fn on_init(&self, server: &CosmicusServer) {
    log::info!("MyPlugin on_init");
    self.server.lock().unwrap().replace(server.clone());
  }

  fn on_event(&self, event: &WorkflowMessage) {
    log::info!("MyPlugin on_event: {:?}", event);
  }

  fn on_runner_registered(&self, _runner: &cosmicus::RegisterRunner) {
    log::info!("MyPlugin on_runner_registered");
    let event = WorkflowEvent::API(WorkflowAPIEvent {
      repo_owner: "panghu-huang".to_string(),
      repo_name: "octocrate".to_string(),
      ref_name: "refs/heads/main".to_string(),
      sha: "95409faeae0e81635075091f56888e4bb5fc1a76".to_string(),
      pr_number: None,
    });

    let server = self.server.lock().unwrap().clone().unwrap();
    let workflow = server
      .parse_workflow(CreateWorkflowOptions {
        config: WORKFLOW.to_string(),
        event: event.clone(),
      })
      .unwrap();

    tokio::spawn(async move {
      log::info!("MyPlugin on_runner_registered: run_workflow");

      run_workflow("1")
        .workflow(workflow)
        .event(event)
        .exec(&server)
        .await
        .unwrap();
      log::info!("MyPlugin on_runner_registered: run_workflow done");
    });
  }

  fn on_run_workflow(&self, _options: &RunWorkflowConfig) {
    log::info!("MyPlugin on_run_workflow");
  }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
  dotenv::dotenv().ok();

  let _res = env_logger::builder()
    .target(env_logger::Target::Stdout)
    .filter_level(log::LevelFilter::Info)
    .try_init();

  let app_id = env::var("GITHUB_APP_ID").map_err(|e| {
    anyhow::anyhow!(
      "Failed to read Github App ID from environment variable GITHUB_APP_ID: {}",
      e
    )
  })?;

  let private_key_path = env::var("GITHUB_APP_PRIVATE_KEY_PATH")
    .map_err(|e| anyhow::anyhow!("Failed to read Github App private key path: {}", e))?;
  let private_key = fs::read_to_string(&private_key_path).map_err(|e| {
    anyhow::anyhow!(
      "Failed to read Github App private key from {}: {}",
      private_key_path,
      e
    )
  })?;

  let server = CosmicusServer::builder()
    .port(5001 as u32)
    .host("127.0.0.1")
    .github_app_id(app_id.parse::<u64>()?)
    .github_app_private_key(private_key)
    .build()?;

  server
    .register_secret(
      Secret::new("test_secret")
        .value("test_value")
        .owner("panghu-huang")
        .build()?,
    )
    .register_plugin(MyPlugin::new());

  server.run().await.unwrap();

  Ok(())
}