use plan::Plan;
use project::ProjectPlan;

mod plan;
mod project;

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

    let _cuddle = Cuddle::default()
        .prepare_project()
        .await?
        .prepare_plan()
        .await?;

    Ok(())
}

struct Start {}
struct PrepareProject {
    project: Option<ProjectPlan>,
}

struct PreparePlan {
    project: Option<ProjectPlan>,
    plan: Option<Plan>,
}

struct Cuddle<S = Start> {
    state: S,
}

// Cuddle maintains the context for cuddle to use
// Stage 1 figure out which state to display
// Stage 2 prepare plan
// Stage 3 validate settings, build actions, prepare
impl Cuddle {}

impl Cuddle<Start> {
    pub fn default() -> Self {
        Self { state: Start {} }
    }

    pub async fn prepare_project(&self) -> anyhow::Result<Cuddle<PrepareProject>> {
        let project = ProjectPlan::from_current_path().await?;

        Ok(Cuddle {
            state: PrepareProject { project },
        })
    }
}

impl Cuddle<PrepareProject> {
    pub async fn prepare_plan(&self) -> anyhow::Result<Cuddle<PreparePlan>> {
        if let Some(project) = &self.state.project {
            match Plan::new().clone_from_project(project).await? {
                Some(plan) => todo!(),
                None => todo!(),
            }
        }

        todo!()
    }
}