use std::process;

use anyhow::{bail, Context, Result};
use log::{error, info};

use crate::{cli::OpenCommand, rofi, task};

pub fn handle(command: OpenCommand) -> Result<()> {
    match command {
        OpenCommand::Review => {
            for project in task::Project::all().context("Failed to get all project files")? {
                if project.is_touched() {
                    info!("Reviewing project: '{}'", project.to_project_display());
                    open_in_browser(project).with_context(|| {
                        format!(
                            "Failed to open project ('{}') in Firefox",
                            project.to_project_display()
                        )
                    })?;
                    project.untouch().with_context(|| {
                        format!(
                            "Failed to untouch project ('{}')",
                            project.to_project_display()
                        )
                    })?;
                }
            }
        }
        OpenCommand::Project { project } => {
            let project = if let Some(p) = project {
                p
            } else if let Some(p) =
                task::Project::get_current().context("Failed to get currently focused project")?
            {
                p
            } else {
                bail!("You need to either supply a project or have a project active!");
            };

            project.touch().context("Failed to touch project")?;
            open_in_browser(&project).with_context(|| {
                format!("Failed to open project: {}", project.to_project_display())
            })?;
        }
        OpenCommand::Select => {
            let selected_project: task::Project = task::Project::from_project_string(
                &rofi::select(
                    task::Project::all()
                        .context("Failed to get all registered projects")?
                        .iter()
                        .map(task::Project::to_project_display)
                        .collect::<Vec<_>>()
                        .as_slice(),
                )
                .context("Failed to get selected project")?,
            )
            .expect("This should work, as we send only projects in");

            selected_project
                .touch()
                .context("Failed to touch project")?;

            open_in_browser(&selected_project).context("Failed to open project")?;
        }
        OpenCommand::ListTabs { project } => {
            let project = if let Some(p) = project {
                p
            } else if let Some(p) =
                task::Project::get_current().context("Failed to get currently focused project")?
            {
                p
            } else {
                bail!("You need to either supply a project or have a project active!");
            };

            let session_store = project.get_sessionstore().with_context(|| {
                format!(
                    "Failed to get session store for project: '{}'",
                    project.to_project_display()
                )
            })?;

            let selected = session_store
                .windows
                .iter()
                .map(|w| w.selected)
                .collect::<Vec<_>>();

            let tabs = session_store
                .windows
                .iter()
                .flat_map(|window| window.tabs.iter())
                .map(|tab| tab.entries.get(tab.index - 1).expect("This should be Some"))
                .collect::<Vec<_>>();

            for (index, entry) in tabs.iter().enumerate() {
                let index = index + 1;
                let is_selected = {
                    if selected.contains(&index) {
                        "🔻 "
                    } else {
                        "   "
                    }
                };
                println!("{}{}", is_selected, entry.url);
            }
        }
    }
    Ok(())
}

fn open_in_browser(selected_project: &task::Project) -> Result<()> {
    let old_project: Option<task::Project> =
        task::Project::get_current().context("Failed to get currently active project")?;
    // We have ensured that only one task may be active
    let old_task: Option<task::Id> =
        task::Id::get_current().context("Failed to get currently active task")?;

    selected_project.activate().with_context(|| {
        format!(
            "Failed to active project: '{}'",
            selected_project.to_project_display()
        )
    })?;

    let tracking_task = {
        let all_tasks = selected_project.get_tasks().with_context(|| {
            format!(
                "Failed to get assoctiated tasks for project: '{}'",
                selected_project.to_project_display()
            )
        })?;

        let tracking_task = all_tasks.into_iter().find(|t| {
            let maybe_desc = t.description();
            if let Ok(desc) = maybe_desc {
                desc == "tracking"
            } else {
                error!(
                    "Getting task description returned error: {}",
                    maybe_desc.expect_err("We already check for Ok")
                );
                false
            }
        });

        if let Some(task) = tracking_task {
            info!(
                "Starting task {} -> tracking",
                selected_project.to_project_display()
            );
            task.start()
                .with_context(|| format!("Failed to start task {task}"))?;
        }
        tracking_task
    };

    let status = process::Command::new("firefox")
        .args([
            "-P",
            selected_project.to_project_display().as_str(),
            "about:newtab",
        ])
        .status()
        .context("Failed to start firefox")?;

    if !status.success() {
        error!("Firefox run exited with error.");
    }

    if let Some(task) = tracking_task {
        task.stop()
            .with_context(|| format!("Failed to stop task {task}"))?;
    }
    if let Some(task) = old_task {
        task.start()
            .with_context(|| format!("Failed to start task {task}"))?;
    }

    if let Some(project) = old_project {
        project.activate().with_context(|| {
            format!("Failed to active project {}", project.to_project_display())
        })?;
    } else {
        task::Project::clear().context("Failed to clear currently focused project")?;
    }

    Ok(())
}