// wasm-ui/src/lib.rs

#[function_component(App)]
pub fn app() -> Html {
    // Repository data from repos.json
    let repo_data = use_state(|| None::<RepoData>);

    // Local git status from API
    let local_statuses = use_state(|| HashMap::<String, LocalRepoStatus>::new());

    // UI state
    let active_tab = use_state(|| 0_usize);
    let sort_column = use_state(|| SortColumn::Status);
    let sort_direction = use_state(|| SortDirection::Ascending);

    // Dialog visibility
    let show_add_group = use_state(|| false);
    let show_add_root = use_state(|| false);
    let show_create_pr = use_state(|| None::<CreatePrState>);

    // Refresh timer
    let refresh_counter = use_state(|| 0_u32);

    // ... component logic
}

// Fetch repository data
let fetch_repos = {
    let repo_data = repo_data.clone();
    Callback::from(move |_| {
        let repo_data = repo_data.clone();
        wasm_bindgen_futures::spawn_local(async move {
            match fetch_json::<RepoData>("/repos.json").await {
                Ok(data) => repo_data.set(Some(data)),
                Err(e) => log::error!("Failed to fetch repos: {:?}", e),
            }
        });
    })
};

// Fetch local status
let fetch_status = {
    let local_statuses = local_statuses.clone();
    Callback::from(move |_| {
        let local_statuses = local_statuses.clone();
        wasm_bindgen_futures::spawn_local(async move {
            match fetch_json::<LocalStatusResponse>("/api/local-repos/status").await {
                Ok(resp) => {
                    let map: HashMap<_, _> = resp.statuses.into_iter()
                        .map(|s| (s.repo_id.clone(), s))
                        .collect();
                    local_statuses.set(map);
                }
                Err(e) => log::error!("Failed to fetch status: {:?}", e),
            }
        });
    })
};

fn calculate_repo_status_priority(
    repo: &Repository,
    local_status: Option<&LocalRepoStatus>,
) -> u32 {
    // Priority 0 (RED - MOST URGENT): Needs sync
    // Check local status for unpushed/behind
    if let Some(status) = local_status {
        if status.unpushed_commits > 0 || status.behind_commits > 0 {
            return 0; // needs-sync
        }
    }

    // Check GitHub branches for ahead/behind
    for branch in &repo.branches {
        if branch.ahead > 0 || branch.behind > 0 {
            return 0; // needs-sync
        }
    }

    // Priority 1 (YELLOW - 2nd MOST URGENT): Local changes
    if let Some(status) = local_status {
        if status.uncommitted_files > 0 {
            return 1; // local-changes
        }
    }

    // Priority 2 (WHITE - CLEANUP): Stale branches
    let unmerged_count = repo.branches.iter()
        .filter(|b| !["main", "master", "develop"].contains(&b.name.as_str()))
        .filter(|b| b.status == "ReadyForPR" || b.status == "NeedsSync")
        .count();

    if unmerged_count > 0 {
        return 2; // stale
    }

    // Priority 3 (GREEN - ALL CLEAR): Complete
    3 // complete
}

fn render_status_icon(priority: u32, title: &str) -> Html {
    let (icon_name, alt_text) = match priority {
        0 => ("needs-sync", "Needs sync"),
        1 => ("local-changes", "Local changes"),
        2 => ("stale", "Stale branches"),
        _ => ("complete", "Complete"),
    };

    html! {
        <img
            class="status-icon"
            src={format!("/icons/{}.png", icon_name)}
            alt={alt_text}
            title={title}
        />
    }
}

// Calculate worst-case status for tab icon
let tab_status_priority = group.repos.iter()
    .map(|repo| calculate_repo_status_priority(repo, local_statuses.get(&repo.id)))
    .min()  // Minimum priority number = worst status
    .unwrap_or(3);

let tab_title = match tab_status_priority {
    0 => "🛑 STOP: Has uncommitted, unpushed, or unfetched commits",
    1 => "⚠️ YIELD: Has local uncommitted changes",
    2 => "ℹ️ CLEAN UP: Has unmerged feature branches",
    _ => "✅ PROCEED: All repositories up to date",
};

html! {
    <div class="tab" onclick={switch_tab}>
        {render_status_icon(tab_status_priority, tab_title)}
        <span>{&group.name}</span>
    </div>
}

// Switch active tab
let switch_tab = {
    let active_tab = active_tab.clone();
    Callback::from(move |index: usize| {
        active_tab.set(index);
    })
};

// Sort table by column
let sort_by_column = {
    let sort_column = sort_column.clone();
    let sort_direction = sort_direction.clone();
    Callback::from(move |column: SortColumn| {
        if *sort_column == column {
            // Toggle direction
            sort_direction.set(match *sort_direction {
                SortDirection::Ascending => SortDirection::Descending,
                SortDirection::Descending => SortDirection::Ascending,
            });
        } else {
            sort_column.set(column);
            sort_direction.set(SortDirection::Ascending);
        }
    })
};

// Open create PR dialog
let open_create_pr_dialog = {
    let show_create_pr = show_create_pr.clone();
    Callback::from(move |repo: Repository| {
        show_create_pr.set(Some(CreatePrState {
            repo,
            title: String::new(),
            body: String::new(),
            base: "main".to_string(),
        }));
    })
};

// Create PR form submit
let submit_create_pr = {
    let show_create_pr = show_create_pr.clone();
    let refresh_counter = refresh_counter.clone();

    Callback::from(move |e: SubmitEvent| {
        e.prevent_default();

        let show_create_pr = show_create_pr.clone();
        let refresh_counter = refresh_counter.clone();

        if let Some(state) = (*show_create_pr).clone() {
            wasm_bindgen_futures::spawn_local(async move {
                let request = CreatePrRequest {
                    owner: state.repo.owner,
                    repo: state.repo.name,
                    branch: state.branch,
                    base: state.base,
                    title: state.title,
                    body: state.body,
                };

                match post_json("/api/repos/create-pr", &request).await {
                    Ok(_) => {
                        show_create_pr.set(None);
                        refresh_counter.set(*refresh_counter + 1);
                    }
                    Err(e) => {
                        log::error!("Failed to create PR: {:?}", e);
                        // Show error to user
                    }
                }
            });
        }
    })
};

use wasm_bindgen::JsCast;
use web_sys::{Request, RequestInit, RequestMode, Response};

async fn fetch_json<T: serde::de::DeserializeOwned>(url: &str) -> Result<T, JsValue> {
    let window = web_sys::window().unwrap();

    let mut opts = RequestInit::new();
    opts.method("GET");
    opts.mode(RequestMode::Cors);

    let request = Request::new_with_str_and_init(url, &opts)?;

    let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
    let resp: Response = resp_value.dyn_into()?;

    let json = JsFuture::from(resp.json()?).await?;

    serde_wasm_bindgen::from_value(json)
        .map_err(|e| JsValue::from_str(&format!("Deserialize error: {:?}", e)))
}

async fn post_json<T, R>(url: &str, body: &T) -> Result<R, JsValue>
where
    T: serde::Serialize,
    R: serde::de::DeserializeOwned,
{
    let window = web_sys::window().unwrap();

    let mut opts = RequestInit::new();
    opts.method("POST");
    opts.mode(RequestMode::Cors);

    let body_str = serde_json::to_string(body)
        .map_err(|e| JsValue::from_str(&format!("Serialize error: {:?}", e)))?;
    opts.body(Some(&JsValue::from_str(&body_str)));

    let request = Request::new_with_str_and_init(url, &opts)?;
    request.headers().set("Content-Type", "application/json")?;

    let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
    let resp: Response = resp_value.dyn_into()?;

    if !resp.ok() {
        return Err(JsValue::from_str(&format!("HTTP {}", resp.status())));
    }

    let json = JsFuture::from(resp.json()?).await?;
    serde_wasm_bindgen::from_value(json)
        .map_err(|e| JsValue::from_str(&format!("Deserialize error: {:?}", e)))
}

use gloo_timers::callback::Interval;

// In App component
use_effect_with_deps(
    move |_| {
        let refresh_counter = refresh_counter.clone();

        // Set up 60-second interval
        let interval = Interval::new(60_000, move || {
            refresh_counter.set(*refresh_counter + 1);
        });

        // Cleanup on unmount
        move || drop(interval)
    },
    (),
);

// Trigger refetch when refresh_counter changes
use_effect_with_deps(
    move |counter| {
        let repo_data = repo_data.clone();
        let local_statuses = local_statuses.clone();

        wasm_bindgen_futures::spawn_local(async move {
            // Fetch repos.json
            if let Ok(data) = fetch_json::<RepoData>("/repos.json").await {
                repo_data.set(Some(data));
            }

            // Fetch local status
            if let Ok(resp) = fetch_json::<LocalStatusResponse>("/api/local-repos/status").await {
                let map: HashMap<_, _> = resp.statuses.into_iter()
                    .map(|s| (s.repo_id.clone(), s))
                    .collect();
                local_statuses.set(map);
            }
        });

        || ()
    },
    (*refresh_counter,),
);

use std::rc::Rc;

// Memoize expensive calculations
let sorted_repos = use_memo(
    (repo_data.clone(), sort_column.clone(), sort_direction.clone()),
    |(data, column, direction)| {
        if let Some(data) = data.as_ref() {
            let mut repos = data.repos.clone();
            sort_repos(&mut repos, column, direction);
            Rc::new(repos)
        } else {
            Rc::new(vec![])
        }
    },
);

// Only render visible rows (virtual scrolling for large lists)
let visible_repos = use_memo(
    (sorted_repos.clone(), scroll_position.clone()),
    |(repos, scroll_pos)| {
        let start_index = (scroll_pos / ROW_HEIGHT).max(0);
        let end_index = (start_index + VISIBLE_ROWS).min(repos.len());
        repos[start_index..end_index].to_vec()
    },
);

#[cfg(test)]
mod tests {
    use super::*;
    use yew::functional::function_component;

    #[test]
    fn test_status_calculation() {
        let repo = Repository {
            id: "owner/repo".to_string(),
            branches: vec![],
            // ...
        };

        let status = LocalRepoStatus {
            unpushed_commits: 5,
            // ...
        };

        let priority = calculate_repo_status_priority(&repo, Some(&status));
        assert_eq!(priority, 0); // Should be needs-sync
    }

    #[test]
    fn test_tab_aggregation() {
        let repos = vec![
            create_repo_with_status(0),  // needs-sync
            create_repo_with_status(1),  // local-changes
            create_repo_with_status(3),  // complete
        ];

        let worst = repos.iter()
            .map(|r| calculate_repo_status_priority(r, None))
            .min()
            .unwrap();

        assert_eq!(worst, 0); // Should show needs-sync
    }
}