atmos/apps/onedrive/

mod.rs

//! Microsoft OneDrive ネイティブクライアント（Graph API 経由）。
//!
//! [`crate::apps::drive`]（Google Drive）と同じ設計。ブラウザで onedrive.live.com を
//! 描画するのではなく、[`crate::os_lib::cloud`] の Microsoft Graph REST + OAuth2
//! デバイスフローを使い、AtmOS ネイティブ UI で OneDrive を読み書きする。Microsoft の
//! device flow はパブリッククライアント向けのため client_secret が不要で、Google Drive
//! アプリより設定項目が少ない。通信は同期的（TLS ハンドシェイク + 受信待ち）に行うため、
//! 操作キー押下時に数百 ms ブロックする（drive/browser 等の既存挙動と同じ）。
// onedrive/mod.rs - Microsoft OneDrive native client (Graph API 経由) for AtmOS
#![allow(dead_code)]

extern crate alloc;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;

use crate::kernel::draw::{Color, Screen};
use crate::kernel::text_box::TextBox;
use crate::kernel::window_mgr::App;
use crate::os_lib::cloud::{self, MsAuth, OneDriveFile};

/// どのペインにフォーカスしているか。
#[derive(PartialEq, Clone, Copy)]
enum Pane {
    Remote,
    Local,
}

pub struct OneDriveApp {
    auth: MsAuth,
    // 一覧
    remote: Vec<OneDriveFile>,
    local: Vec<String>,
    remote_sel: usize,
    local_sel: usize,
    pane: Pane,
    scroll: usize,
    // フォルダ階層: ルートからの (id, name) パス。空 = OneDrive ルート直下を表示中。
    folder_path: Vec<(String, String)>,
    // ログインフロー
    device_user_code: String,
    device_url: String,
    device_code: String,
    awaiting_auth: bool,
    // ビューア（ファイル本文表示。テキストとして解釈できた場合のみ）
    viewer_open: bool,
    viewer_title: String,
    viewer_text: String,
    viewer_scroll: usize,
    // 状態行
    status: String,
    // 直近の描画サイズ（マウスのペイン判定用）
    last_win_w: u32,
    // client_id 設定モード（onedrive_auth.json を手動編集せずアプリ内で設定できる）。
    // Microsoft の device flow は client_secret 不要のため入力欄は1つだけ。
    setup_mode: bool,
    setup_id_box: TextBox,
}

impl Default for OneDriveApp {
    fn default() -> Self {
        Self::new()
    }
}

impl OneDriveApp {
    pub fn new() -> Self {
        let auth = cloud::load_ms_auth();
        let mut app = Self {
            auth,
            remote: Vec::new(),
            local: Vec::new(),
            remote_sel: 0,
            local_sel: 0,
            pane: Pane::Remote,
            scroll: 0,
            folder_path: Vec::new(),
            device_user_code: String::new(),
            device_url: String::new(),
            device_code: String::new(),
            awaiting_auth: false,
            viewer_open: false,
            viewer_title: String::new(),
            viewer_text: String::new(),
            viewer_scroll: 0,
            status: String::new(),
            last_win_w: 900,
            setup_mode: false,
            setup_id_box: TextBox::new(),
        };
        app.reload_local();
        if app.auth.is_logged_in() {
            app.status = String::from("Logged in. Press R to load OneDrive files.");
        } else if app.auth.has_client() {
            app.status = String::from("Press L to log in to OneDrive.");
        } else {
            app.status = String::from("Setup required: press S to enter client_id.");
        }
        app
    }

    fn reload_local(&mut self) {
        let fs = crate::kernel::fs::get_fs();
        self.local = fs
            .list_files()
            .iter()
            .map(|m| m.get_filename().to_string())
            .collect();
        if self.local_sel >= self.local.len() {
            self.local_sel = 0;
        }
    }

    /// access_token が空、または期限切れ時に refresh_token で更新を試みる。成功で true。
    fn try_refresh(&mut self) -> bool {
        if self.auth.refresh_token.is_empty() || !self.auth.has_client() {
            return false;
        }
        match cloud::onedrive_refresh_token(&self.auth.client_id, &self.auth.refresh_token) {
            Ok(tok) if !tok.access_token.is_empty() => {
                self.auth.access_token = tok.access_token;
                if !tok.refresh_token.is_empty() {
                    self.auth.refresh_token = tok.refresh_token;
                }
                // 更新したトークンを保存できなければ次回起動時にまたログインが
                // 必要になる。継続はできるので理由を表示・記録して先へ進む。
                if let Err(e) = cloud::save_ms_auth(&self.auth) {
                    crate::error!("[ONEDRIVE] refreshed token not saved: {}", e);
                    self.status = alloc::format!("Warning: token not saved ({})", e);
                }
                true
            }
            _ => false,
        }
    }

    // ---- アクション ----

    fn action_login(&mut self) {
        if !self.auth.has_client() {
            self.status = String::from("No client_id. Press S to enter it first.");
            return;
        }
        self.status = String::from("Requesting device code...");
        match cloud::onedrive_request_device_code(&self.auth.client_id) {
            Ok(dc) if !dc.user_code.is_empty() => {
                self.device_user_code = dc.user_code;
                self.device_url = dc.verification_url;
                self.device_code = dc.device_code;
                self.awaiting_auth = true;
                self.status =
                    String::from("Open the URL on another device, enter the code, then press P.");
            }
            Ok(_) => {
                self.status =
                    String::from("Device code request returned empty (check client_id/scope).")
            }
            Err(e) => self.status = format!("Device code error: {}", e),
        }
    }

    fn action_poll(&mut self) {
        if !self.awaiting_auth {
            return;
        }
        self.status = String::from("Polling for authorization...");
        match cloud::onedrive_poll_token(&self.auth.client_id, &self.device_code) {
            Ok(tok) if !tok.access_token.is_empty() => {
                self.auth.access_token = tok.access_token;
                if !tok.refresh_token.is_empty() {
                    self.auth.refresh_token = tok.refresh_token;
                }
                self.awaiting_auth = false;
                match cloud::save_ms_auth(&self.auth) {
                    Ok(()) => self.status = String::from("Logged in! Loading OneDrive files..."),
                    Err(e) => {
                        crate::error!("[ONEDRIVE] login token not saved: {}", e);
                        self.status = alloc::format!(
                            "Logged in, but token NOT saved ({}). Login will not persist.",
                            e
                        );
                    }
                }
                self.action_refresh_remote();
            }
            Ok(tok) if tok.error == "authorization_pending" => {
                self.status =
                    String::from("Still pending. Authorize in browser, then press P again.");
            }
            Ok(tok) if tok.error == "slow_down" => {
                self.status = String::from("Slow down: wait a few seconds, then press P.");
            }
            Ok(tok) if !tok.error.is_empty() => {
                self.status = format!("Auth error: {}", tok.error);
            }
            Ok(_) => self.status = String::from("No token yet. Press P again."),
            Err(e) => self.status = format!("Poll error: {}", e),
        }
    }

    /// 現在のフォルダ（folder_path の末尾。空ならルート）の直下一覧を取得する。
    fn current_folder_id(&self) -> Option<&str> {
        self.folder_path.last().map(|(id, _)| id.as_str())
    }

    fn action_refresh_remote(&mut self) {
        if !self.auth.is_logged_in() {
            self.status = String::from("Not logged in.");
            return;
        }
        self.status = String::from("Loading OneDrive files...");
        let folder_id = self.current_folder_id().map(String::from);
        match cloud::onedrive_list_files_in_folder(&self.auth.access_token, folder_id.as_deref())
        {
            Ok(files) => {
                self.remote = files;
                self.remote_sel = 0;
                self.scroll = 0;
                self.status = format!("Loaded {} OneDrive files.", self.remote.len());
            }
            Err("unauthorized (token expired?)") => {
                if self.try_refresh() {
                    match cloud::onedrive_list_files_in_folder(
                        &self.auth.access_token,
                        folder_id.as_deref(),
                    ) {
                        Ok(files) => {
                            self.remote = files;
                            self.status = format!("Loaded {} OneDrive files.", self.remote.len());
                        }
                        Err(e) => self.status = format!("OneDrive list error after refresh: {}", e),
                    }
                } else {
                    self.status =
                        String::from("Token expired and refresh failed. Press L to re-login.");
                }
            }
            Err(e) => self.status = format!("OneDrive list error: {}", e),
        }
    }

    /// フォルダに入る（folder_path に積んで再読み込み）。
    fn action_enter_folder(&mut self, id: String, name: String) {
        self.folder_path.push((id, name));
        self.action_refresh_remote();
    }

    /// 1階層上に戻る（folder_path から1つ pop して再読み込み）。ルートなら何もしない。
    fn action_leave_folder(&mut self) {
        if self.folder_path.pop().is_some() {
            self.action_refresh_remote();
        }
    }

    /// 選択中の remote ファイルをダウンロードし、テキストとして解釈できればビューアで開く
    /// （フォルダなら代わりに中へ入る）。
    fn action_open_remote(&mut self) {
        if self.remote.is_empty() {
            return;
        }
        let f = self.remote[self.remote_sel].clone();
        if f.is_folder {
            self.action_enter_folder(f.id, f.name);
            return;
        }
        self.status = format!("Fetching '{}'...", f.name);
        let mut result = cloud::onedrive_download_binary(&self.auth.access_token, &f.id);
        if let Err("unauthorized (token expired?)") = result {
            if self.try_refresh() {
                result = cloud::onedrive_download_binary(&self.auth.access_token, &f.id);
            }
        }
        match result {
            Ok(bytes) => {
                self.viewer_title = f.name.clone();
                self.viewer_text = String::from_utf8_lossy(&bytes).into_owned();
                self.viewer_scroll = 0;
                self.viewer_open = true;
                self.status = format!("Opened '{}'. Press V to close.", f.name);
            }
            Err(e) => self.status = format!("Open error: {}", e),
        }
    }

    /// 選択中の remote ファイルの生バイトをそのままローカル FS に保存する
    /// （画像/zip/docx など、テキストビューアでは壊れるファイル向け）。
    fn action_download_remote(&mut self) {
        if self.remote.is_empty() {
            return;
        }
        let f = self.remote[self.remote_sel].clone();
        if f.is_folder {
            self.status = String::from("That is a folder.");
            return;
        }
        self.status = format!("Downloading '{}'...", f.name);
        let mut result = cloud::onedrive_download_binary(&self.auth.access_token, &f.id);
        if let Err("unauthorized (token expired?)") = result {
            if self.try_refresh() {
                result = cloud::onedrive_download_binary(&self.auth.access_token, &f.id);
            }
        }
        match result {
            Ok(bytes) => {
                let len = bytes.len();
                let fs = crate::kernel::fs::get_fs();
                match fs.save_file(&f.name, &bytes, "downloaded") {
                    Ok(()) => {
                        self.status = format!("Downloaded '{}' ({} bytes).", f.name, len);
                        self.reload_local();
                    }
                    Err(e) => self.status = format!("Download save error: {}", e),
                }
            }
            Err(e) => self.status = format!("Download error: {}", e),
        }
    }

    fn action_upload_local(&mut self) {
        if !self.auth.is_logged_in() {
            self.status = String::from("Not logged in.");
            return;
        }
        if self.local.is_empty() {
            return;
        }
        let name = self.local[self.local_sel].clone();
        let fs = crate::kernel::fs::get_fs();
        let content = match fs.read_file(&name) {
            Some((_m, bytes)) => bytes,
            None => {
                self.status = format!("Local file '{}' not found.", name);
                return;
            }
        };
        self.status = format!("Uploading '{}'...", name);
        let folder_id = self.current_folder_id().map(String::from);
        let mut result = cloud::onedrive_upload_binary(
            &self.auth.access_token,
            folder_id.as_deref(),
            &name,
            &content,
        );
        if let Err("unauthorized (token expired?)") = result {
            if self.try_refresh() {
                result = cloud::onedrive_upload_binary(
                    &self.auth.access_token,
                    folder_id.as_deref(),
                    &name,
                    &content,
                );
            }
        }
        match result {
            Ok(id) => {
                self.status = format!("Uploaded '{}' (id={}). Press R to refresh.", name, id);
            }
            Err(e) => self.status = format!("Upload error: {}", e),
        }
    }

    fn action_delete_remote(&mut self) {
        if self.remote.is_empty() {
            return;
        }
        let f = self.remote[self.remote_sel].clone();
        self.status = format!("Deleting '{}'...", f.name);
        let mut result = cloud::onedrive_delete(&self.auth.access_token, &f.id);
        if let Err("unauthorized (token expired?)") = result {
            if self.try_refresh() {
                result = cloud::onedrive_delete(&self.auth.access_token, &f.id);
            }
        }
        match result {
            Ok(()) => {
                self.remote.remove(self.remote_sel);
                if self.remote_sel >= self.remote.len() && self.remote_sel > 0 {
                    self.remote_sel -= 1;
                }
                self.status = format!("Deleted '{}'.", f.name);
            }
            Err(e) => self.status = format!("Delete error: {}", e),
        }
    }

    fn action_logout(&mut self) {
        self.auth.access_token = String::new();
        self.auth.refresh_token = String::new();
        self.remote.clear();
        self.folder_path.clear();
        // 保存に失敗するとディスク上にトークンが残るため、
        // 「ログアウトしました」と表示してはいけない。
        match cloud::save_ms_auth(&self.auth) {
            Ok(()) => {
                self.status = String::from("Logged out (client_id kept). Press L to log in.")
            }
            Err(e) => {
                crate::error!("[ONEDRIVE] logout not persisted: {}", e);
                self.status =
                    alloc::format!("Logout NOT saved ({}). Token may remain on disk!", e);
            }
        }
    }

    /// client_id 設定モードに入る。現在の値を入力欄の初期値にする
    /// （`onedrive_auth.json` を手動編集しなくても、アプリ内でこの入力から書き込める）。
    fn action_enter_setup(&mut self) {
        self.setup_id_box = TextBox::with_text(&self.auth.client_id);
        self.setup_mode = true;
    }

    /// 入力欄の内容を client_id として保存する。
    fn action_save_setup(&mut self) {
        self.auth.client_id = self.setup_id_box.text.clone();
        match cloud::save_ms_auth(&self.auth) {
            Ok(()) => {
                self.setup_mode = false;
                self.status = if self.auth.has_client() {
                    String::from("Saved client_id. Press L to log in.")
                } else {
                    String::from("Saved, but client_id still empty.")
                };
            }
            Err(e) => self.status = format!("Save error: {}", e),
        }
    }
}

const HEADER_H: u32 = 28;
const ROW_H: u32 = 20;

impl App for OneDriveApp {
    fn name(&self) -> &str {
        "onedrive"
    }

    fn instance_info(&self) -> String {
        if self.auth.is_logged_in() {
            String::from("OneDrive")
        } else {
            String::from("OneDrive (logged out)")
        }
    }

    fn draw(&mut self, screen: &Screen, win_x: u32, win_y: u32, win_w: u32, win_h: u32) {
        self.last_win_w = win_w;
        let config = crate::kernel::config::get_config();
        // 背景
        screen.boxfill(
            win_x,
            win_y,
            win_x + win_w,
            win_y + win_h,
            Color(config.theme.app_bg),
        );
        // ヘッダ
        screen.boxfill(
            win_x,
            win_y,
            win_x + win_w,
            win_y + HEADER_H,
            Color(config.theme.window_title_bar),
        );
        screen.draw_string_vector(win_x + 12, win_y + 7, "OneDrive", Color(config.theme.window_title_fg), 16);
        let legend =
            "L:login P:poll R:refresh Enter:open/enter U:upload B:download D:delete BS:up-folder Tab:pane V:close O:logout S:setup";
        screen.draw_string_vector(win_x + 130, win_y + 9, legend, Color(config.theme.non_active_window_border), 11);

        let body_y = win_y + HEADER_H + 4;

        // client_id 設定モード。onedrive_auth.json を手動編集しなくてもここで書き込める。
        if self.setup_mode {
            screen.draw_string_vector(
                win_x + 14,
                body_y + 4,
                "Azure Portal (portal.azure.com): App registrations > New registration,",
                Color(config.theme.non_active_window_border),
                12,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 22,
                "Supported account types: any, no redirect URI needed (public client, device code flow).",
                Color(config.theme.non_active_window_border),
                12,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 40,
                "API permissions: Files.ReadWrite + offline_access (Microsoft Graph, delegated).",
                Color(config.theme.non_active_window_border),
                12,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 62,
                "Application (client) ID:",
                Color(config.theme.terminal_fg),
                13,
            );
            self.draw_text_field(
                screen,
                win_x + 14,
                body_y + 80,
                win_w - 28,
                &self.setup_id_box,
                true,
                "(paste client_id / Application ID)",
                false,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 118,
                "Enter: save   Esc: cancel",
                Color(config.theme.non_active_window_border),
                12,
            );
            self.draw_status(screen, win_x, win_y, win_w, win_h);
            return;
        }

        // セットアップ未完了 or ログインフロー表示
        if !self.auth.has_client() {
            let lines = [
                "Setup required.",
                "Press S to enter your Azure App client_id directly in this app,",
                "or save it into 'onedrive_auth.json' yourself:",
                "1. Azure Portal (portal.azure.com): App registrations > New registration.",
                "   Supported account types: any. No redirect URI needed.",
                "2. Enable 'Allow public client flows' (device code).",
                "3. API permissions: Files.ReadWrite + offline_access (Microsoft Graph).",
                "4. Press S here, paste the client_id (Application ID), press Enter to save.",
            ];
            let mut y = body_y + 6;
            for l in lines.iter() {
                screen.draw_string_vector(win_x + 14, y, l, Color(config.theme.terminal_fg), 12);
                y += 20;
            }
            self.draw_status(screen, win_x, win_y, win_w, win_h);
            return;
        }

        if self.awaiting_auth {
            screen.draw_string_vector(
                win_x + 14,
                body_y + 10,
                "Authorize this device:",
                Color(config.theme.terminal_fg),
                14,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 40,
                "1. Open this URL on your phone/PC:",
                Color(config.theme.non_active_window_border),
                12,
            );
            screen.draw_string_vector(
                win_x + 30,
                body_y + 62,
                &self.device_url,
                Color(config.theme.active_window_border),
                13,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 92,
                "2. Enter this code:",
                Color(config.theme.non_active_window_border),
                12,
            );
            screen.draw_string_vector(
                win_x + 30,
                body_y + 116,
                &self.device_user_code,
                Color(config.theme.focus_highlight),
                24,
            );
            screen.draw_string_vector(
                win_x + 14,
                body_y + 152,
                "3. Press P here to complete login.",
                Color(config.theme.non_active_window_border),
                12,
            );
            self.draw_status(screen, win_x, win_y, win_w, win_h);
            return;
        }

        // ビューア（本文表示）が開いていれば全面に
        if self.viewer_open {
            screen.draw_string_vector(
                win_x + 14,
                body_y,
                &format!("View: {}", self.viewer_title),
                Color(config.theme.focus_highlight),
                14,
            );
            let mut y = body_y + 24;
            let max_y = win_y + win_h - 28;
            for line in self.viewer_text.lines().skip(self.viewer_scroll) {
                if y + ROW_H > max_y {
                    break;
                }
                // 長い行は切り詰め
                let shown: String = line.chars().take(90).collect();
                screen.draw_string_vector(win_x + 14, y, &shown, Color(config.theme.terminal_fg), 12);
                y += 16;
            }
            self.draw_status(screen, win_x, win_y, win_w, win_h);
            return;
        }

        // パンくず（OneDrive ルートからの現在フォルダのパス）。ルート表示中は "/" のみ。
        let mut crumb = String::from("/");
        for (_, name) in self.folder_path.iter() {
            crumb.push_str(name);
            crumb.push('/');
        }
        let crumb_shown: String = crumb.chars().take(80).collect();
        screen.draw_string_vector(
            win_x + 14,
            body_y,
            &crumb_shown,
            Color(config.theme.non_active_window_border),
            11,
        );

        // 2ペイン: 左 OneDrive / 右 Local
        let mid_x = win_x + win_w / 2;
        let remote_focus = self.pane == Pane::Remote;
        let pane_header_y = body_y + 16;
        screen.draw_string_vector(
            win_x + 14,
            pane_header_y,
            "OneDrive (remote)",
            if remote_focus {
                Color(config.theme.active_window_border)
            } else {
                Color(config.theme.non_active_window_border)
            },
            13,
        );
        screen.draw_string_vector(
            mid_x + 14,
            pane_header_y,
            "Local (this OS)",
            if !remote_focus {
                Color(config.theme.active_window_border)
            } else {
                Color(config.theme.non_active_window_border)
            },
            13,
        );

        let list_y = pane_header_y + 22;
        let max_rows = ((win_h - HEADER_H - 76) / ROW_H) as usize;

        // 左: remote
        for (i, f) in self
            .remote
            .iter()
            .enumerate()
            .skip(self.scroll)
            .take(max_rows)
        {
            let y = list_y + (i - self.scroll) as u32 * ROW_H;
            if remote_focus && i == self.remote_sel {
                screen.boxfill(
                    win_x + 8,
                    y - 2,
                    mid_x - 8,
                    y + ROW_H - 4,
                    Color(config.theme.button_active_bg),
                );
            }
            let tag = if f.is_folder { "[D] " } else { "    " };
            let label: String = format!("{}{}", tag, f.name);
            let shown: String = label.chars().take(40).collect();
            screen.draw_string_vector(win_x + 14, y, &shown, Color(config.theme.terminal_fg), 12);
        }
        if self.remote.is_empty() {
            screen.draw_string_vector(
                win_x + 14,
                list_y,
                "(press R to load)",
                Color(config.theme.non_active_window_border),
                12,
            );
        }

        // 右: local
        for (i, name) in self.local.iter().enumerate().take(max_rows) {
            let y = list_y + i as u32 * ROW_H;
            if !remote_focus && i == self.local_sel {
                screen.boxfill(
                    mid_x + 8,
                    y - 2,
                    win_x + win_w - 8,
                    y + ROW_H - 4,
                    Color(config.theme.button_active_bg),
                );
            }
            let shown: String = name.chars().take(40).collect();
            screen.draw_string_vector(mid_x + 14, y, &shown, Color(config.theme.terminal_fg), 12);
        }

        self.draw_status(screen, win_x, win_y, win_w, win_h);
    }

    fn on_key(&mut self, keycode: u8, pressed: bool, ascii: Option<char>) {
        if !pressed {
            return;
        }
        // client_id 設定モード: Enter で保存、Esc でキャンセル、それ以外は入力欄へ転送。
        if self.setup_mode {
            match keycode {
                0x1C => self.action_save_setup(),
                0x01 => {
                    self.setup_mode = false;
                    self.status = String::from("Setup cancelled.");
                }
                _ => {
                    let _ = self.setup_id_box.handle_key(keycode, ascii);
                }
            }
            return;
        }
        let c = match ascii {
            Some(c) => c.to_ascii_lowercase(),
            None => return,
        };
        // ビューア表示中はスクロール/閉じるのみ
        if self.viewer_open {
            match c {
                'v' | 'q' => self.viewer_open = false,
                'j' => self.viewer_scroll = self.viewer_scroll.saturating_add(1),
                'k' => self.viewer_scroll = self.viewer_scroll.saturating_sub(1),
                _ => {}
            }
            return;
        }
        match c {
            'l' => self.action_login(),
            'p' => self.action_poll(),
            'r' => self.action_refresh_remote(),
            'u' => self.action_upload_local(),
            'd' => self.action_delete_remote(),
            'o' => self.action_logout(),
            's' => self.action_enter_setup(),
            'b' if self.pane == Pane::Remote => self.action_download_remote(),
            '\x08' if self.pane == Pane::Remote => self.action_leave_folder(),
            '\t' => {
                self.pane = if self.pane == Pane::Remote {
                    Pane::Local
                } else {
                    Pane::Remote
                }
            }
            '\n' | '\r' => {
                if self.pane == Pane::Remote {
                    self.action_open_remote();
                } else {
                    self.action_upload_local();
                }
            }
            'j' => self.move_sel(1),
            'k' => self.move_sel(-1),
            _ => {}
        }
    }

    fn on_mouse(
        &mut self,
        local_x: i32,
        local_y: i32,
        btn_left: bool,
        _btn_right: bool,
        wheel: i32,
    ) {
        if wheel != 0 && self.viewer_open {
            if wheel < 0 {
                self.viewer_scroll = self.viewer_scroll.saturating_add(1);
            } else {
                self.viewer_scroll = self.viewer_scroll.saturating_sub(1);
            }
            return;
        }
        if !btn_left {
            return;
        }
        // 行選択: ヘッダ下のリスト領域でクリックされたペイン/行を選ぶ
        let list_top = (HEADER_H + 26) as i32;
        if local_y < list_top {
            return;
        }
        let row = ((local_y - list_top) / ROW_H as i32).max(0) as usize;
        // クリック x がウィンドウ中央より左なら remote ペイン、右なら local ペイン。
        // フォーカスもそのペインへ移す。
        let mid = (self.last_win_w / 2) as i32;
        if local_x < mid {
            self.pane = Pane::Remote;
            if row + self.scroll < self.remote.len() {
                self.remote_sel = row + self.scroll;
            }
        } else {
            self.pane = Pane::Local;
            if row < self.local.len() {
                self.local_sel = row;
            }
        }
    }
}

impl OneDriveApp {
    fn move_sel(&mut self, delta: i32) {
        if self.pane == Pane::Remote {
            let n = self.remote.len();
            if n == 0 {
                return;
            }
            let cur = self.remote_sel as i32 + delta;
            self.remote_sel = cur.clamp(0, n as i32 - 1) as usize;
        } else {
            let n = self.local.len();
            if n == 0 {
                return;
            }
            let cur = self.local_sel as i32 + delta;
            self.local_sel = cur.clamp(0, n as i32 - 1) as usize;
        }
    }

    #[allow(clippy::too_many_arguments)]
    fn draw_text_field(
        &self,
        screen: &Screen,
        x: u32,
        y: u32,
        w: u32,
        tb: &TextBox,
        focused: bool,
        placeholder: &str,
        mask: bool,
    ) {
        let t = &crate::kernel::config::get_config().theme;
        let border = if focused { t.active_window_border } else { t.browser_secondary };
        let bg = if focused { t.browser_bg } else { t.ui_input_bg };
        screen.boxfill(x, y, x + w, y + 28, Color(bg));
        screen.boxfill(x, y, x + w, y + 1, Color(border));
        screen.boxfill(x, y + 27, x + w, y + 28, Color(border));
        screen.boxfill(x, y, x + 1, y + 28, Color(border));
        screen.boxfill(x + w - 1, y, x + w, y + 28, Color(border));

        let display: String = if tb.text.is_empty() && !focused {
            String::from(placeholder)
        } else if focused {
            tb.get_text_with_cursor(true)
                .chars()
                .map(|c| if mask && c != '|' { '*' } else { c })
                .collect()
        } else if mask {
            tb.text.chars().map(|_| '*').collect()
        } else {
            tb.text.clone()
        };

        let text_color = if tb.text.is_empty() && !focused {
            t.fn_bar_dim_fg
        } else {
            t.login_text_fg
        };
        let shown: String = display.chars().take(60).collect();
        screen.draw_string_vector(x + 8, y + 7, &shown, Color(text_color), 13);
    }

    fn draw_status(&self, screen: &Screen, win_x: u32, win_y: u32, win_w: u32, win_h: u32) {
        let config = crate::kernel::config::get_config();
        let bar_y = win_y + win_h - 24;
        screen.boxfill(
            win_x,
            bar_y,
            win_x + win_w,
            win_y + win_h,
            Color(config.theme.window_title_bar),
        );
        let shown: String = self.status.chars().take(110).collect();
        screen.draw_string_vector(win_x + 12, bar_y + 5, &shown, Color(config.theme.window_title_fg), 12);
    }
}