synpad 0.1.0

use dioxus::prelude::*;
use futures_util::StreamExt;
use matrix_sdk::encryption::verification::{
    QrVerification, QrVerificationData, QrVerificationState, VerificationRequest,
    VerificationRequestState,
};
use matrix_sdk::ruma::events::key::verification::VerificationMethod;
use qrcode::render::unicode::Dense1x2;

use crate::components::modal::Modal;
use crate::platform::file_dialog::{FileFilter, pick_file};
use crate::state::app_state::AppState;

fn render_qr_code(verification: &QrVerification) -> Result<String, String> {
    let qr = verification
        .to_qr_code()
        .map_err(|e| format!("Failed to render verification QR code: {e}"))?;

    Ok(qr
        .render::<Dense1x2>()
        .quiet_zone(false)
        .module_dimensions(1, 1)
        .build())
}

fn decode_qr_payload(bytes: &[u8]) -> Result<Vec<u8>, String> {
    let image = image::load_from_memory(bytes)
        .map_err(|e| format!("Failed to open QR image: {e}"))?
        .to_luma8();
    let mut decoder = quircs::Quirc::default();

    for code in decoder.identify(image.width() as usize, image.height() as usize, &image) {
        let code = code.map_err(|e| format!("Failed to read QR image: {e}"))?;
        let decoded = code
            .decode()
            .map_err(|e| format!("Failed to decode QR code: {e}"))?;
        return Ok(decoded.payload);
    }

    Err("No QR code was found in the selected image".to_string())
}

fn update_qr_progress(
    qr_state: QrVerificationState,
    mut status: Signal<String>,
    mut awaiting_confirmation: Signal<bool>,
    mut verified: Signal<bool>,
    mut error: Signal<Option<String>>,
) -> bool {
    match qr_state {
        QrVerificationState::Started => {
            status.set("Verification request is ready. Show or scan the QR code.".to_string());
            false
        }
        QrVerificationState::Reciprocated => {
            status.set("QR code scanned. Waiting for the other device to continue.".to_string());
            false
        }
        QrVerificationState::Scanned => {
            awaiting_confirmation.set(true);
            status.set("QR code scanned. Confirm on this device to finish verification.".to_string());
            false
        }
        QrVerificationState::Confirmed => {
            awaiting_confirmation.set(false);
            status.set("Confirmation sent. Waiting for verification to complete.".to_string());
            false
        }
        QrVerificationState::Done { .. } => {
            awaiting_confirmation.set(false);
            verified.set(true);
            status.set("Device verification completed successfully.".to_string());
            true
        }
        QrVerificationState::Cancelled(cancel_info) => {
            awaiting_confirmation.set(false);
            error.set(Some(format!("Verification cancelled: {cancel_info:?}")));
            true
        }
    }
}

async fn watch_qr_changes(
    qr: QrVerification,
    status: Signal<String>,
    awaiting_confirmation: Signal<bool>,
    verified: Signal<bool>,
    error: Signal<Option<String>>,
) {
    if update_qr_progress(
        qr.state(),
        status,
        awaiting_confirmation,
        verified,
        error,
    ) {
        return;
    }

    let mut changes = qr.changes();
    while let Some(qr_state) = changes.next().await {
        if update_qr_progress(qr_state, status, awaiting_confirmation, verified, error) {
            break;
        }
    }
}

async fn watch_request_changes(
    request: VerificationRequest,
    mut active_qr: Signal<Option<QrVerification>>,
    mut qr_display: Signal<Option<String>>,
    mut status: Signal<String>,
    awaiting_confirmation: Signal<bool>,
    mut verified: Signal<bool>,
    mut error: Signal<Option<String>>,
) {
    let mut changes = request.changes();

    while let Some(request_state) = changes.next().await {
        match request_state {
            VerificationRequestState::Created { .. } => {
                status.set("Verification request created. Waiting for the other device.".to_string());
            }
            VerificationRequestState::Requested { .. } => {
                status.set("Open another logged-in device and accept the verification request.".to_string());
            }
            VerificationRequestState::Ready { .. } => {
                status.set("Verification accepted. QR code is ready.".to_string());
                let has_qr = active_qr.read().is_some();
                if has_qr {
                    continue;
                }

                match request.generate_qr_code().await {
                    Ok(Some(qr)) => match render_qr_code(&qr) {
                        Ok(rendered) => {
                            qr_display.set(Some(rendered));
                            active_qr.set(Some(qr.clone()));
                            spawn(watch_qr_changes(
                                qr,
                                status,
                                awaiting_confirmation,
                                verified,
                                error,
                            ));
                        }
                        Err(err) => error.set(Some(err)),
                    },
                    Ok(None) => {
                        status.set("The other device is not ready for QR verification yet.".to_string());
                    }
                    Err(err) => {
                        error.set(Some(format!("Failed to generate QR verification: {err}")));
                    }
                }
            }
            VerificationRequestState::Transitioned { .. } => {
                status.set(
                    "This verification switched to a different method. Use emoji verification on the other device if needed."
                        .to_string(),
                );
            }
            VerificationRequestState::Done => {
                verified.set(true);
                status.set("Device verification completed successfully.".to_string());
                break;
            }
            VerificationRequestState::Cancelled(cancel_info) => {
                error.set(Some(format!("Verification cancelled: {cancel_info:?}")));
                break;
            }
        }
    }
}

/// QR code verification dialog.
#[component]
pub fn QrVerificationDialog(on_close: EventHandler<()>) -> Element {
    let state = use_context::<Signal<AppState>>();
    let mut active_qr = use_signal(|| Option::<QrVerification>::None);
    let mut error = use_signal(|| Option::<String>::None);
    let mut flow_id = use_signal(String::new);
    let mut loading = use_signal(|| true);
    let mut loaded = use_signal(|| false);
    let mut mode = use_signal(|| QrMode::ShowCode);
    let qr_display = use_signal(|| Option::<String>::None);
    let mut request_status = use_signal(|| "Starting verification request...".to_string());
    let mut verification_request = use_signal(|| Option::<VerificationRequest>::None);
    let awaiting_confirmation = use_signal(|| false);
    let verified = use_signal(|| false);
    let mut scan_busy = use_signal(|| false);

    if !*loaded.read() {
        loaded.set(true);
        spawn(async move {
            let client = { state.read().client.clone() };
            let Some(client) = client else {
                error.set(Some("Not logged in".to_string()));
                loading.set(false);
                return;
            };
            let Some(user_id) = client.user_id().map(ToOwned::to_owned) else {
                error.set(Some("Unable to determine the current user".to_string()));
                loading.set(false);
                return;
            };

            let methods = vec![
                VerificationMethod::SasV1,
                VerificationMethod::QrCodeScanV1,
                VerificationMethod::QrCodeShowV1,
                VerificationMethod::ReciprocateV1,
            ];

            match client.encryption().get_user_identity(&user_id).await {
                Ok(Some(identity)) => match identity.request_verification_with_methods(methods).await {
                    Ok(request) => {
                        flow_id.set(request.flow_id().to_string());
                        verification_request.set(Some(request.clone()));
                        request_status.set(
                            "Verification request sent. Accept it on your other device to continue."
                                .to_string(),
                        );
                        spawn(watch_request_changes(
                            request,
                            active_qr,
                            qr_display,
                            request_status,
                            awaiting_confirmation,
                            verified,
                            error,
                        ));
                    }
                    Err(err) => {
                        error.set(Some(format!("Failed to create verification request: {err}")));
                    }
                },
                Ok(None) => {
                    error.set(Some(
                        "Your account identity is not available yet. Wait for sync and try again."
                            .to_string(),
                    ));
                }
                Err(err) => {
                    error.set(Some(format!("Failed to load your identity: {err}")));
                }
            }

            loading.set(false);
        });
    }

    rsx! {
        Modal {
            title: "Verify with QR Code".to_string(),
            on_close: move |_| on_close.call(()),

            div {
                class: "qr-verification",

                div {
                    class: "qr-verification__tabs",
                    button {
                        class: if *mode.read() == QrMode::ShowCode {
                            "qr-verification__tab qr-verification__tab--active"
                        } else {
                            "qr-verification__tab"
                        },
                        onclick: move |_| mode.set(QrMode::ShowCode),
                        "Show QR Code"
                    }
                    button {
                        class: if *mode.read() == QrMode::ScanCode {
                            "qr-verification__tab qr-verification__tab--active"
                        } else {
                            "qr-verification__tab"
                        },
                        onclick: move |_| mode.set(QrMode::ScanCode),
                        "Scan QR Code"
                    }
                }

                if *loading.read() {
                    div {
                        class: "qr-verification__loading",
                        div { class: "spinner" }
                        span { "Preparing verification request..." }
                    }
                } else {
                    p {
                        class: "qr-verification__instructions",
                        "{request_status}"
                    }

                    if !flow_id.read().is_empty() {
                        p {
                            class: "qr-verification__hint",
                            "Flow ID: {flow_id}"
                        }
                    }

                    if let Some(ref err) = *error.read() {
                        div { class: "qr-verification__error", "{err}" }
                    }

                    if *verified.read() {
                        div {
                            class: "security-status",
                            span { class: "security-status__icon security-status__icon--ok", "✅" }
                            div {
                                class: "security-status__info",
                                span { class: "security-status__label", "Verification complete" }
                                span {
                                    class: "security-status__description",
                                    "This device is now verified."
                                }
                            }
                        }
                    } else if *mode.read() == QrMode::ShowCode {
                        div {
                            class: "qr-verification__show",
                            if let Some(ref rendered) = *qr_display.read() {
                                pre {
                                    class: "qr-verification__grid",
                                    "{rendered}"
                                }
                                p {
                                    class: "qr-verification__instructions",
                                    "Scan this code from your other Matrix client."
                                }
                            } else {
                                p {
                                    class: "qr-verification__hint",
                                    "The QR code will appear here once the other device accepts the verification request."
                                }
                            }
                        }
                    } else {
                        div {
                            class: "qr-verification__scan",
                            p { "Choose an image containing the QR code shown by your other device." }
                            button {
                                class: "btn btn--primary",
                                disabled: *scan_busy.read(),
                                onclick: move |_| {
                                    error.set(None);
                                    scan_busy.set(true);
                                    let request = verification_request.read().as_ref().cloned();
                                    spawn(async move {
                                        let Some(request) = request else {
                                            error.set(Some("Verification request is not available yet.".to_string()));
                                            scan_busy.set(false);
                                            return;
                                        };

                                        let file = match pick_file(
                                            "Choose a QR code image",
                                            &[FileFilter {
                                                name: "Images",
                                                extensions: &["png", "jpg", "jpeg", "bmp", "gif", "webp"],
                                            }],
                                        )
                                        .await
                                        {
                                            Ok(Some(file)) => file,
                                            Ok(None) => {
                                                scan_busy.set(false);
                                                return;
                                            }
                                            Err(err) => {
                                                error.set(Some(err));
                                                scan_busy.set(false);
                                                return;
                                            }
                                        };

                                        let image_bytes = file.bytes;
                                        let payload = match decode_qr_payload(&image_bytes) {
                                            Ok(payload) => payload,
                                            Err(err) => {
                                                error.set(Some(err));
                                                scan_busy.set(false);
                                                return;
                                            }
                                        };

                                        let qr_data = match QrVerificationData::from_bytes(payload) {
                                            Ok(data) => data,
                                            Err(err) => {
                                                error.set(Some(format!("The selected QR code is not a Matrix verification code: {err}")));
                                                scan_busy.set(false);
                                                return;
                                            }
                                        };

                                        match request.scan_qr_code(qr_data).await {
                                            Ok(Some(qr)) => {
                                                request_status.set(
                                                    "QR code imported. Waiting for the verification exchange to continue."
                                                        .to_string(),
                                                );
                                                active_qr.set(Some(qr.clone()));
                                                spawn(watch_qr_changes(
                                                    qr,
                                                    request_status,
                                                    awaiting_confirmation,
                                                    verified,
                                                    error,
                                                ));
                                            }
                                            Ok(None) => {
                                                error.set(Some(
                                                    "This verification flow is not ready to scan a QR code yet. Accept it on the other device first."
                                                        .to_string(),
                                                ));
                                            }
                                            Err(err) => {
                                                error.set(Some(format!("Failed to scan QR code: {err}")));
                                            }
                                        }

                                        scan_busy.set(false);
                                    });
                                },
                                if *scan_busy.read() { "Scanning..." } else { "Choose QR Image" }
                            }
                            p {
                                class: "qr-verification__hint",
                                "Desktop builds use image import instead of a live camera feed."
                            }
                        }
                    }

                    div {
                        class: "qr-verification__actions",
                        if *awaiting_confirmation.read() {
                            button {
                                class: "btn btn--primary",
                                onclick: move |_| {
                                    if let Some(qr) = active_qr.read().as_ref().cloned() {
                                        error.set(None);
                                        spawn(async move {
                                            if let Err(err) = qr.confirm().await {
                                                error.set(Some(format!("Failed to confirm QR verification: {err}")));
                                            }
                                        });
                                    }
                                },
                                "Confirm Scan"
                            }
                        }
                        button {
                            class: "btn btn--secondary",
                            onclick: move |_| {
                                let qr = active_qr.read().as_ref().cloned();
                                let request = verification_request.read().as_ref().cloned();
                                spawn(async move {
                                    if let Some(qr) = qr {
                                        let _ = qr.cancel().await;
                                    } else if let Some(request) = request {
                                        let _ = request.cancel().await;
                                    }
                                });
                                on_close.call(());
                            },
                            "Close"
                        }
                    }
                }
            }
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
enum QrMode {
    ShowCode,
    ScanCode,
}