git.stevedylan.dev

Merge pull request #25 from stevedylandev/chore/refactor-jotts fe0b8be9

Refactor Jotts

Steve Simkins · 2026-04-16 17:20 8 file(s) · +1243 −1305

apps/jotts/src/backend.rs +65 −66

1		-	use crate::db::{self, Db, Note};
	1	+	use crate::db::{self, Db, Note, NoteInput};
	2	+	use reqwest::StatusCode;
	3	+	use reqwest::blocking::{Client, RequestBuilder, Response};
2	4		use std::fmt;
3	5
4	6		#[derive(Debug)]

29	31		}
30	32		}
31	33
	34	+	fn net<E: fmt::Display>(e: E) -> BackendError {
	35	+	BackendError::Network(e.to_string())
	36	+	}
	37	+
	38	+	fn with_key(req: RequestBuilder, key: &Option<String>) -> RequestBuilder {
	39	+	match key {
	40	+	Some(k) => req.header("x-api-key", k),
	41	+	None => req,
	42	+	}
	43	+	}
	44	+
	45	+	fn send_request(req: RequestBuilder) -> Result<Response, BackendError> {
	46	+	let resp = req.send().map_err(net)?;
	47	+	match resp.status().as_u16() {
	48	+	401 => Err(BackendError::Unauthorized("Invalid API key".into())),
	49	+	403 => Err(BackendError::Unauthorized(
	50	+	"No API key configured on server".into(),
	51	+	)),
	52	+	_ => Ok(resp),
	53	+	}
	54	+	}
	55	+
	56	+	fn unexpected(status: StatusCode) -> BackendError {
	57	+	BackendError::Network(format!("HTTP {}", status))
	58	+	}
	59	+
32	60		pub enum Backend {
33	61		Local {
34	62		db: Db,

36	64		Remote {
37	65		base_url: String,
38	66		api_key: Option<String>,
39		-	client: reqwest::blocking::Client,
	67	+	client: Client,
40	68		},
41	69		}
42	70

49	77		Backend::Remote {
50	78		base_url,
51	79		api_key,
52		-	client: reqwest::blocking::Client::new(),
	80	+	client: Client::new(),
53	81		}
54	82		}
55	83

61	89		api_key,
62	90		client,
63	91		} => {
64		-	let mut req = client.get(format!("{}/api/notes", base_url));
65		-	if let Some(key) = api_key {
66		-	req = req.header("x-api-key", key);
67		-	}
68		-	let resp = req
69		-	.send()
70		-	.map_err(\|e\| BackendError::Network(e.to_string()))?;
	92	+	let req = with_key(client.get(format!("{base_url}/api/notes")), api_key);
	93	+	let resp = send_request(req)?;
71	94		match resp.status().as_u16() {
72		-	200 => resp
73		-	.json::<Vec<Note>>()
74		-	.map_err(\|e\| BackendError::Network(e.to_string())),
75		-	401 => Err(BackendError::Unauthorized("Invalid API key".into())),
76		-	403 => Err(BackendError::Unauthorized(
77		-	"No API key configured on server".into(),
78		-	)),
79		-	_ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),
	95	+	200 => resp.json::<Vec<Note>>().map_err(net),
	96	+	_ => Err(unexpected(resp.status())),
80	97		}
81	98		}
82	99		}

90	107		api_key,
91	108		client,
92	109		} => {
93		-	let mut req = client
94		-	.post(format!("{}/api/notes", base_url))
95		-	.json(&serde_json::json!({"title": title, "content": content}));
96		-	if let Some(key) = api_key {
97		-	req = req.header("x-api-key", key);
98		-	}
99		-	let resp = req
100		-	.send()
101		-	.map_err(\|e\| BackendError::Network(e.to_string()))?;
	110	+	let body = NoteInput {
	111	+	title: title.to_string(),
	112	+	content: content.to_string(),
	113	+	};
	114	+	let req = with_key(
	115	+	client.post(format!("{base_url}/api/notes")).json(&body),
	116	+	api_key,
	117	+	);
	118	+	let resp = send_request(req)?;
102	119		match resp.status().as_u16() {
103		-	201 => resp
104		-	.json::<Note>()
105		-	.map_err(\|e\| BackendError::Network(e.to_string())),
106		-	401 => Err(BackendError::Unauthorized("Invalid API key".into())),
107		-	403 => Err(BackendError::Unauthorized(
108		-	"No API key configured on server".into(),
109		-	)),
110		-	_ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),
	120	+	201 => resp.json::<Note>().map_err(net),
	121	+	_ => Err(unexpected(resp.status())),
111	122		}
112	123		}
113	124		}

126	137		api_key,
127	138		client,
128	139		} => {
129		-	let mut req = client
130		-	.put(format!("{}/api/notes/{}", base_url, short_id))
131		-	.json(&serde_json::json!({"title": title, "content": content}));
132		-	if let Some(key) = api_key {
133		-	req = req.header("x-api-key", key);
134		-	}
135		-	let resp = req
136		-	.send()
137		-	.map_err(\|e\| BackendError::Network(e.to_string()))?;
	140	+	let body = NoteInput {
	141	+	title: title.to_string(),
	142	+	content: content.to_string(),
	143	+	};
	144	+	let req = with_key(
	145	+	client
	146	+	.put(format!("{base_url}/api/notes/{short_id}"))
	147	+	.json(&body),
	148	+	api_key,
	149	+	);
	150	+	let resp = send_request(req)?;
138	151		match resp.status().as_u16() {
139		-	200 => resp
140		-	.json::<Note>()
141		-	.map(Some)
142		-	.map_err(\|e\| BackendError::Network(e.to_string())),
143		-	401 => Err(BackendError::Unauthorized("Invalid API key".into())),
144		-	403 => Err(BackendError::Unauthorized(
145		-	"No API key configured on server".into(),
146		-	)),
	152	+	200 => resp.json::<Note>().map(Some).map_err(net),
147	153		404 => Ok(None),
148		-	_ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),
	154	+	_ => Err(unexpected(resp.status())),
149	155		}
150	156		}
151	157		}

159	165		api_key,
160	166		client,
161	167		} => {
162		-	let mut req = client.delete(format!("{}/api/notes/{}", base_url, short_id));
163		-	if let Some(key) = api_key {
164		-	req = req.header("x-api-key", key);
165		-	}
166		-	let resp = req
167		-	.send()
168		-	.map_err(\|e\| BackendError::Network(e.to_string()))?;
	168	+	let req = with_key(
	169	+	client.delete(format!("{base_url}/api/notes/{short_id}")),
	170	+	api_key,
	171	+	);
	172	+	let resp = send_request(req)?;
169	173		match resp.status().as_u16() {
170	174		200 \| 204 => Ok(true),
171		-	401 => Err(BackendError::Unauthorized("Invalid API key".into())),
172		-	403 => Err(BackendError::Unauthorized(
173		-	"No API key configured on server".into(),
174		-	)),
175	175		404 => Ok(false),
176		-	_ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),
	176	+	_ => Err(unexpected(resp.status())),
177	177		}
178	178		}
179	179		}
180	180		}
181	181		}
182		-

apps/jotts/src/db.rs +63 −96

use nanoid::nanoid;
use rusqlite::{Connection, params};
use rusqlite::{Connection, OptionalExtension, Row, params};
use serde::{Deserialize, Serialize};
use std::fmt;
use std::sync::{Arc, Mutex};

pub type Db = Arc<Mutex<Connection>>;

const NOTE_COLUMNS: &str = "id, short_id, title, content, created_at, updated_at";

const SCHEMA: &str = "
    CREATE TABLE IF NOT EXISTS notes (
        id         INTEGER PRIMARY KEY AUTOINCREMENT,
        short_id   TEXT NOT NULL UNIQUE,
        title      TEXT NOT NULL,
        content    TEXT NOT NULL,
        created_at TEXT NOT NULL DEFAULT (datetime('now')),
        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
    );

    CREATE TABLE IF NOT EXISTS sessions (
        id         INTEGER PRIMARY KEY AUTOINCREMENT,
        token      TEXT NOT NULL UNIQUE,
        expires_at TEXT NOT NULL
    );
";

#[derive(Debug)]
pub enum DbError {
    Sqlite(rusqlite::Error),

    pub updated_at: String,
}

impl Note {
    fn from_row(row: &Row) -> rusqlite::Result<Self> {
        Ok(Note {
            id: row.get(0)?,
            short_id: row.get(1)?,
            title: row.get(2)?,
            content: row.get(3)?,
            created_at: row.get(4)?,
            updated_at: row.get(5)?,
        })
    }
}

/// Incoming note payload from JSON/form requests. Shared by server and backend.
#[derive(Debug, Serialize, Deserialize)]
pub struct NoteInput {
    pub title: String,
    pub content: String,
}

pub fn init_db() -> Db {
    let path = std::env::var("JOTTS_DB_PATH").unwrap_or_else(|_| "jotts.sqlite".to_string());
    let conn = Connection::open(&path).expect("Failed to open database");

    conn.execute_batch(
        "CREATE TABLE IF NOT EXISTS notes (
            id         INTEGER PRIMARY KEY AUTOINCREMENT,
            short_id   TEXT NOT NULL UNIQUE,
            title      TEXT NOT NULL,
            content    TEXT NOT NULL,
            created_at TEXT NOT NULL DEFAULT (datetime('now')),
            updated_at TEXT NOT NULL DEFAULT (datetime('now'))
        );

        CREATE TABLE IF NOT EXISTS sessions (
            id         INTEGER PRIMARY KEY AUTOINCREMENT,
            token      TEXT NOT NULL UNIQUE,
            expires_at TEXT NOT NULL
        );"
    )
    .expect("Failed to create tables");

    conn.execute_batch(SCHEMA).expect("Failed to create tables");
    Arc::new(Mutex::new(conn))
}


    )?;
    let id = conn.last_insert_rowid();
    let note = conn.query_row(
        "SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE id = ?1",
        &format!("SELECT {NOTE_COLUMNS} FROM notes WHERE id = ?1"),
        params![id],
        |row| {
            Ok(Note {
                id: row.get(0)?,
                short_id: row.get(1)?,
                title: row.get(2)?,
                content: row.get(3)?,
                created_at: row.get(4)?,
                updated_at: row.get(5)?,
            })
        },
        Note::from_row,
    )?;
    Ok(note)
}

pub fn get_note_by_short_id(db: &Db, short_id: &str) -> Result<Option<Note>, DbError> {
    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;
    match conn.query_row(
        "SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE short_id = ?1",
        params![short_id],
        |row| {
            Ok(Note {
                id: row.get(0)?,
                short_id: row.get(1)?,
                title: row.get(2)?,
                content: row.get(3)?,
                created_at: row.get(4)?,
                updated_at: row.get(5)?,
            })
        },
    ) {
        Ok(note) => Ok(Some(note)),
        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
        Err(e) => Err(DbError::Sqlite(e)),
    }
    let note = conn
        .query_row(
            &format!("SELECT {NOTE_COLUMNS} FROM notes WHERE short_id = ?1"),
            params![short_id],
            Note::from_row,
        )
        .optional()?;
    Ok(note)
}

pub fn get_all_notes(db: &Db) -> Result<Vec<Note>, DbError> {
    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;
    let mut stmt = conn.prepare(
        "SELECT id, short_id, title, content, created_at, updated_at FROM notes ORDER BY id DESC",
    )?;
    let mut stmt =
        conn.prepare(&format!("SELECT {NOTE_COLUMNS} FROM notes ORDER BY id DESC"))?;
    let notes = stmt
        .query_map([], |row| {
            Ok(Note {
                id: row.get(0)?,
                short_id: row.get(1)?,
                title: row.get(2)?,
                content: row.get(3)?,
                created_at: row.get(4)?,
                updated_at: row.get(5)?,
            })
        })?
        .query_map([], Note::from_row)?
        .collect::<Result<Vec<_>, _>>()?;
    Ok(notes)
}

    if rows == 0 {
        return Ok(None);
    }
    match conn.query_row(
        "SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE short_id = ?1",
        params![short_id],
        |row| {
            Ok(Note {
                id: row.get(0)?,
                short_id: row.get(1)?,
                title: row.get(2)?,
                content: row.get(3)?,
                created_at: row.get(4)?,
                updated_at: row.get(5)?,
            })
        },
    ) {
        Ok(note) => Ok(Some(note)),
        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
        Err(e) => Err(DbError::Sqlite(e)),
    }
    let note = conn
        .query_row(
            &format!("SELECT {NOTE_COLUMNS} FROM notes WHERE short_id = ?1"),
            params![short_id],
            Note::from_row,
        )
        .optional()?;
    Ok(note)
}

pub fn delete_note_by_short_id(db: &Db, short_id: &str) -> Result<bool, DbError> {


    fn test_db() -> Db {
        let conn = Connection::open_in_memory().unwrap();
        conn.execute_batch(
            "CREATE TABLE IF NOT EXISTS notes (
                id         INTEGER PRIMARY KEY AUTOINCREMENT,
                short_id   TEXT NOT NULL UNIQUE,
                title      TEXT NOT NULL,
                content    TEXT NOT NULL,
                created_at TEXT NOT NULL DEFAULT (datetime('now')),
                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
            );
            CREATE TABLE IF NOT EXISTS sessions (
                id         INTEGER PRIMARY KEY AUTOINCREMENT,
                token      TEXT NOT NULL UNIQUE,
                expires_at TEXT NOT NULL
            );",
        )
        .unwrap();
        conn.execute_batch(SCHEMA).unwrap();
        Arc::new(Mutex::new(conn))
    }


apps/jotts/src/server.rs +60 −102

use std::sync::Arc;

use crate::auth;
use crate::db::{self, Db, Note};
use crate::db::{self, Db, DbError, Note, NoteInput};

impl IntoResponse for DbError {
    fn into_response(self) -> Response {
        tracing::error!("{}", self);
        (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
    }
}

fn redirect_with_cookie(target: &str, cookie: String) -> Response {
    let mut resp = Redirect::to(target).into_response();
    resp.headers_mut().insert(
        axum::http::header::SET_COOKIE,
        HeaderValue::from_str(&cookie).unwrap(),
    );
    resp
}

#[derive(Clone)]
pub struct AppState {

    password: String,
}

#[derive(serde::Deserialize)]
struct NoteForm {
    title: String,
    content: String,
}

#[derive(serde::Deserialize)]
struct NoteJson {
    title: String,
    content: String,
}

// --- API key middleware ---

async fn api_key_guard(


// --- JSON API handlers ---

async fn api_list_notes(State(state): State<Arc<AppState>>) -> Response {
    match db::get_all_notes(&state.db) {
        Ok(notes) => Json(notes).into_response(),
        Err(e) => {
            tracing::error!("Failed to list notes: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
        }
    }
async fn api_list_notes(State(state): State<Arc<AppState>>) -> Result<Response, DbError> {
    Ok(Json(db::get_all_notes(&state.db)?).into_response())
}

async fn api_get_note(
    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
) -> Response {
    match db::get_note_by_short_id(&state.db, &short_id) {
        Ok(Some(note)) => Json(note).into_response(),
        Ok(None) => StatusCode::NOT_FOUND.into_response(),
        Err(e) => {
            tracing::error!("Failed to get note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
        }
    }
) -> Result<Response, DbError> {
    Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
        Some(note) => Json(note).into_response(),
        None => StatusCode::NOT_FOUND.into_response(),
    })
}

async fn api_create_note(
    State(state): State<Arc<AppState>>,
    Json(body): Json<NoteJson>,
) -> Response {
    Json(body): Json<NoteInput>,
) -> Result<Response, DbError> {
    let title = body.title.trim();
    if title.is_empty() {
        return (StatusCode::BAD_REQUEST, "title required").into_response();
    }
    match db::create_note(&state.db, title, &body.content) {
        Ok(note) => (StatusCode::CREATED, Json(note)).into_response(),
        Err(e) => {
            tracing::error!("Failed to create note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
        }
        return Ok((StatusCode::BAD_REQUEST, "title required").into_response());
    }
    let note = db::create_note(&state.db, title, &body.content)?;
    Ok((StatusCode::CREATED, Json(note)).into_response())
}

async fn api_update_note(
    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
    Json(body): Json<NoteJson>,
) -> Response {
    Json(body): Json<NoteInput>,
) -> Result<Response, DbError> {
    let title = body.title.trim();
    if title.is_empty() {
        return (StatusCode::BAD_REQUEST, "title required").into_response();
    }
    match db::update_note_by_short_id(&state.db, &short_id, title, &body.content) {
        Ok(Some(note)) => Json(note).into_response(),
        Ok(None) => StatusCode::NOT_FOUND.into_response(),
        Err(e) => {
            tracing::error!("Failed to update note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
        }
        return Ok((StatusCode::BAD_REQUEST, "title required").into_response());
    }
    Ok(
        match db::update_note_by_short_id(&state.db, &short_id, title, &body.content)? {
            Some(note) => Json(note).into_response(),
            None => StatusCode::NOT_FOUND.into_response(),
        },
    )
}

async fn api_delete_note(
    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
) -> Response {
    match db::delete_note_by_short_id(&state.db, &short_id) {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => StatusCode::NOT_FOUND.into_response(),
        Err(e) => {
            tracing::error!("Failed to delete note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
        }
    }
) -> Result<Response, DbError> {
    Ok(match db::delete_note_by_short_id(&state.db, &short_id)? {
        true => StatusCode::NO_CONTENT.into_response(),
        false => StatusCode::NOT_FOUND.into_response(),
    })
}

// --- Static file handlers ---

        return Redirect::to("/login?error=Server+error").into_response();
    }

    let cookie = auth::build_session_cookie(&token, state.cookie_secure);
    let mut resp = Redirect::to("/").into_response();
    resp.headers_mut().insert(
        axum::http::header::SET_COOKIE,
        HeaderValue::from_str(&cookie).unwrap(),
    );
    resp
    redirect_with_cookie("/", auth::build_session_cookie(&token, state.cookie_secure))
}

async fn get_logout(State(state): State<Arc<AppState>>, headers: axum::http::HeaderMap) -> Response {

        }
    }

    let cookie = auth::clear_session_cookie();
    let mut resp = Redirect::to("/login").into_response();
    resp.headers_mut().insert(
        axum::http::header::SET_COOKIE,
        HeaderValue::from_str(&cookie).unwrap(),
    );
    resp
    redirect_with_cookie("/login", auth::clear_session_cookie())
}

// --- Note handlers ---

async fn get_index(
    _session: auth::AuthSession,
    State(state): State<Arc<AppState>>,
) -> Response {
    match db::get_all_notes(&state.db) {
        Ok(notes) => WebTemplate(IndexTemplate { notes }).into_response(),
        Err(e) => {
            tracing::error!("Failed to list notes: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
        }
    }
) -> Result<Response, DbError> {
    let notes = db::get_all_notes(&state.db)?;
    Ok(WebTemplate(IndexTemplate { notes }).into_response())
}

async fn get_new_note(

async fn post_create_note(
    _session: auth::AuthSession,
    State(state): State<Arc<AppState>>,
    Form(form): Form<NoteForm>,
    Form(form): Form<NoteInput>,
) -> Response {
    let title = form.title.trim();
    if title.is_empty() {

    _session: auth::AuthSession,
    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
) -> Response {
    match db::get_note_by_short_id(&state.db, &short_id) {
        Ok(Some(note)) => {
) -> Result<Response, DbError> {
    Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
        Some(note) => {
            let rendered_content = render_markdown(&note.content);
            WebTemplate(ViewTemplate {
                note,

            })
            .into_response()
        }
        Ok(None) => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
        Err(e) => {
            tracing::error!("Failed to get note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
        }
    }
        None => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
    })
}

async fn get_edit_note(

    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
    Query(q): Query<FlashQuery>,
) -> Response {
    match db::get_note_by_short_id(&state.db, &short_id) {
        Ok(Some(note)) => WebTemplate(EditTemplate {
) -> Result<Response, DbError> {
    Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
        Some(note) => WebTemplate(EditTemplate {
            note,
            error: q.error,
        })
        .into_response(),
        Ok(None) => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
        Err(e) => {
            tracing::error!("Failed to get note: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
        }
    }
        None => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
    })
}

async fn post_update_note(
    _session: auth::AuthSession,
    State(state): State<Arc<AppState>>,
    Path(short_id): Path<String>,
    Form(form): Form<NoteForm>,
    Form(form): Form<NoteInput>,
) -> Response {
    let title = form.title.trim();
    if title.is_empty() {

apps/jotts/src/tui.rs +14 −1041

mod app;
mod editor;
mod events;
mod render;

use crate::backend::Backend;
use crate::config;
use crate::db::Note;
use crate::highlight::Highlighter;
use app::App;
use arboard::Clipboard;
use crossterm::event::{self, Event, KeyCode, KeyModifiers};
use ratatui::{
    DefaultTerminal,
    layout::{Alignment, Constraint, Layout},
    style::{Color, Modifier, Style},
    text::{Line, Span, Text},
    widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Widget, Wrap},
};
use crossterm::event::{self, Event};
use ratatui::DefaultTerminal;
use std::path::PathBuf;
use std::time::{Duration, Instant};

fn edit_in_external_editor(
    terminal: &mut DefaultTerminal,
    app: &mut App,
    backend: &Backend,
) -> Result<(), Box<dyn std::error::Error>> {
    let (short_id, title, content) = match app.selected_note() {
        Some(n) => (n.short_id.clone(), n.title.clone(), n.content.clone()),
        None => return Ok(()),
    };

    let editor = match std::env::var("EDITOR") {
        Ok(e) if !e.trim().is_empty() => e,
        _ => {
            app.status_message = Some(("EDITOR env not set".to_string(), Instant::now()));
            return Ok(());
        }
    };

    let mut path = std::env::temp_dir();
    path.push(format!("jotts-{}.md", short_id));
    std::fs::write(&path, &content)?;

    ratatui::restore();

    let status = std::process::Command::new(&editor).arg(&path).status();

    *terminal = ratatui::init();
    terminal.clear()?;

    match status {
        Ok(s) if s.success() => {
            let new_content = std::fs::read_to_string(&path)?;
            let _ = std::fs::remove_file(&path);
            if new_content == content {
                app.status_message = Some(("No changes".to_string(), Instant::now()));
                return Ok(());
            }
            match backend.update_note(&short_id, &title, &new_content) {
                Ok(Some(updated)) => {
                    if let Some(pos) = app.notes.iter().position(|n| n.short_id == short_id) {
                        app.notes[pos] = updated;
                    }
                    app.status_message = Some(("Updated!".to_string(), Instant::now()));
                }
                Ok(None) => {
                    app.status_message = Some(("Note not found".to_string(), Instant::now()));
                }
                Err(e) => {
                    app.status_message = Some((e.to_string(), Instant::now()));
                }
            }
        }
        Ok(_) => {
            let _ = std::fs::remove_file(&path);
            app.status_message = Some(("Editor exited non-zero".to_string(), Instant::now()));
        }
        Err(e) => {
            let _ = std::fs::remove_file(&path);
            app.status_message =
                Some((format!("Failed to launch editor: {}", e), Instant::now()));
        }
    }
    Ok(())
}

enum Focus {
    List,
    Content,
    CreateTitle,
    CreateContent,
    EditTitle,
    EditContent,
    Search,
}

struct App {
    notes: Vec<Note>,
    list_state: ListState,
    should_quit: bool,
    status_message: Option<(String, Instant)>,
    focus: Focus,
    content_scroll: u16,
    show_help: bool,
    confirm_delete: bool,
    highlighter: Highlighter,
    edit_title: String,
    edit_content: String,
    edit_short_id: Option<String>,
    search_query: String,
    filtered_indices: Option<Vec<usize>>,
    is_remote: bool,
    remote_url: Option<String>,
    wrap_content: bool,
    edit_scroll: u16,
}

impl App {
    fn new(notes: Vec<Note>, is_remote: bool, remote_url: Option<String>) -> Self {
        let mut list_state = ListState::default();
        if !notes.is_empty() {
            list_state.select(Some(0));
        }
        Self {
            notes,
            list_state,
            should_quit: false,
            status_message: None,
            focus: Focus::List,
            content_scroll: 0,
            show_help: false,
            confirm_delete: false,
            highlighter: Highlighter::new(),
            edit_title: String::new(),
            edit_content: String::new(),
            edit_short_id: None,
            search_query: String::new(),
            filtered_indices: None,
            is_remote,
            remote_url,
            wrap_content: true,
            edit_scroll: 0,
        }
    }

    fn selected_note(&self) -> Option<&Note> {
        self.list_state.selected().and_then(|i| {
            if let Some(indices) = &self.filtered_indices {
                indices.get(i).and_then(|&real| self.notes.get(real))
            } else {
                self.notes.get(i)
            }
        })
    }

    fn visible_count(&self) -> usize {
        match &self.filtered_indices {
            Some(indices) => indices.len(),
            None => self.notes.len(),
        }
    }

    fn move_up(&mut self) {
        let count = self.visible_count();
        if count == 0 {
            return;
        }
        let i = match self.list_state.selected() {
            Some(i) if i > 0 => i - 1,
            Some(_) => count - 1,
            None => 0,
        };
        self.list_state.select(Some(i));
        self.content_scroll = 0;
    }

    fn move_down(&mut self) {
        let count = self.visible_count();
        if count == 0 {
            return;
        }
        let i = match self.list_state.selected() {
            Some(i) if i < count - 1 => i + 1,
            Some(_) => 0,
            None => 0,
        };
        self.list_state.select(Some(i));
        self.content_scroll = 0;
    }

    fn scroll_up(&mut self) {
        self.content_scroll = self.content_scroll.saturating_sub(1);
    }

    fn scroll_down(&mut self, max_lines: u16) {
        if self.content_scroll < max_lines {
            self.content_scroll += 1;
        }
    }

    fn copy_selected(&mut self) {
        if let Some(note) = self.selected_note() {
            if let Ok(mut clipboard) = Clipboard::new() {
                let _ = clipboard.set_text(&note.content);
                self.status_message = Some(("Copied!".to_string(), Instant::now()));
            }
        }
    }

    fn copy_link(&mut self) {
        match &self.remote_url {
            Some(url) => {
                if let Some(note) = self.selected_note() {
                    let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);
                    if let Ok(mut clipboard) = Clipboard::new() {
                        let _ = clipboard.set_text(&link);
                        self.status_message =
                            Some(("Link copied!".to_string(), Instant::now()));
                    }
                }
            }
            None => {
                self.status_message =
                    Some(("No remote URL configured".to_string(), Instant::now()));
            }
        }
    }

    fn open_in_browser(&mut self) {
        match &self.remote_url {
            Some(url) => {
                if let Some(note) = self.selected_note() {
                    let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);
                    if let Err(e) = open::that(&link) {
                        self.status_message =
                            Some((format!("Failed to open browser: {}", e), Instant::now()));
                    } else {
                        self.status_message =
                            Some(("Opened in browser!".to_string(), Instant::now()));
                    }
                }
            }
            None => {
                self.status_message =
                    Some(("No remote URL configured".to_string(), Instant::now()));
            }
        }
    }

    fn delete_selected(&mut self, backend: &Backend) {
        if let Some(selected_index) = self.list_state.selected() {
            let real_index = if let Some(indices) = &self.filtered_indices {
                match indices.get(selected_index) {
                    Some(&ri) => ri,
                    None => return,
                }
            } else {
                selected_index
            };
            if let Some(note) = self.notes.get(real_index) {
                let short_id = note.short_id.clone();
                match backend.delete_note(&short_id) {
                    Ok(true) => {
                        self.notes.remove(real_index);
                        if self.filtered_indices.is_some() {
                            self.update_search_filter();
                        }
                        let count = self.visible_count();
                        if count == 0 {
                            self.list_state.select(None);
                        } else if selected_index >= count {
                            self.list_state.select(Some(count - 1));
                        } else {
                            self.list_state.select(Some(selected_index));
                        }
                        self.status_message = Some(("Deleted!".to_string(), Instant::now()));
                    }
                    Ok(false) => {
                        self.status_message =
                            Some(("Note not found".to_string(), Instant::now()));
                    }
                    Err(e) => {
                        self.status_message = Some((e.to_string(), Instant::now()));
                    }
                }
            }
        }
    }

    fn refresh(&mut self, backend: &Backend) {
        match backend.list_notes() {
            Ok(notes) => {
                self.notes = notes;
                self.filtered_indices = None;
                self.search_query.clear();
                if self.notes.is_empty() {
                    self.list_state.select(None);
                } else {
                    let idx = self.list_state.selected().unwrap_or(0);
                    if idx >= self.notes.len() {
                        self.list_state.select(Some(self.notes.len() - 1));
                    }
                }
                self.status_message = Some(("Refreshed!".to_string(), Instant::now()));
            }
            Err(e) => {
                self.status_message = Some((e.to_string(), Instant::now()));
            }
        }
    }

    fn cursor_position_wrapped(&self, width: u16) -> (u16, u16) {
        let w = width as usize;
        if w == 0 {
            return (0, 0);
        }
        let text = &self.edit_content;
        let mut visual_row: usize = 0;
        let lines: Vec<&str> = if text.is_empty() {
            vec![""]
        } else {
            text.split('\n').collect()
        };
        let last_idx = lines.len() - 1;
        for (i, line) in lines.iter().enumerate() {
            let line_len = line.len();
            let wrapped_lines = if line_len == 0 {
                1
            } else {
                (line_len + w - 1) / w
            };
            if i < last_idx {
                visual_row += wrapped_lines;
            } else {
                let cursor_col = if text.ends_with('\n') { 0 } else { line_len };
                let extra_rows = cursor_col / w;
                let col = cursor_col % w;
                visual_row += extra_rows;
                return (col as u16, visual_row as u16);
            }
        }
        (0, visual_row as u16)
    }

    fn auto_scroll_edit(&mut self, cursor_visual_row: u16, visible_height: u16) {
        if visible_height == 0 {
            return;
        }
        if cursor_visual_row < self.edit_scroll {
            self.edit_scroll = cursor_visual_row;
        } else if cursor_visual_row >= self.edit_scroll + visible_height {
            self.edit_scroll = cursor_visual_row - visible_height + 1;
        }
    }

    fn start_create(&mut self) {
        self.edit_title.clear();
        self.edit_content.clear();
        self.edit_scroll = 0;
        self.focus = Focus::CreateTitle;
    }

    fn save_create(&mut self, backend: &Backend) {
        if self.edit_title.trim().is_empty() {
            self.status_message = Some(("Title cannot be empty".to_string(), Instant::now()));
            return;
        }
        match backend.create_note(&self.edit_title, &self.edit_content) {
            Ok(note) => {
                self.notes.insert(0, note);
                self.list_state.select(Some(0));
                self.filtered_indices = None;
                self.search_query.clear();
                self.status_message = Some(("Created!".to_string(), Instant::now()));
                self.focus = Focus::List;
                self.edit_title.clear();
                self.edit_content.clear();
            }
            Err(e) => {
                self.status_message = Some((e.to_string(), Instant::now()));
            }
        }
    }

    fn cancel_create(&mut self) {
        self.edit_title.clear();
        self.edit_content.clear();
        self.focus = Focus::List;
    }

    fn start_edit(&mut self) {
        let data = self
            .selected_note()
            .map(|n| (n.title.clone(), n.content.clone(), n.short_id.clone()));
        if let Some((title, content, short_id)) = data {
            self.edit_title = title;
            self.edit_content = content;
            self.edit_short_id = Some(short_id);
            self.edit_scroll = 0;
            self.focus = Focus::EditTitle;
        }
    }

    fn save_edit(&mut self, backend: &Backend) {
        if self.edit_title.trim().is_empty() {
            self.status_message = Some(("Title cannot be empty".to_string(), Instant::now()));
            return;
        }
        let short_id = match &self.edit_short_id {
            Some(id) => id.clone(),
            None => return,
        };
        match backend.update_note(&short_id, &self.edit_title, &self.edit_content) {
            Ok(Some(updated)) => {
                if let Some(pos) = self.notes.iter().position(|n| n.short_id == short_id) {
                    self.notes[pos] = updated;
                }
                self.status_message = Some(("Updated!".to_string(), Instant::now()));
                self.focus = Focus::List;
                self.edit_title.clear();
                self.edit_content.clear();
                self.edit_short_id = None;
            }
            Ok(None) => {
                self.status_message = Some(("Note not found".to_string(), Instant::now()));
            }
            Err(e) => {
                self.status_message = Some((e.to_string(), Instant::now()));
            }
        }
    }

    fn cancel_edit(&mut self) {
        self.edit_title.clear();
        self.edit_content.clear();
        self.edit_short_id = None;
        self.focus = Focus::List;
    }

    fn start_search(&mut self) {
        self.search_query.clear();
        self.filtered_indices = Some((0..self.notes.len()).collect());
        self.focus = Focus::Search;
        self.list_state
            .select(if self.notes.is_empty() { None } else { Some(0) });
    }

    fn update_search_filter(&mut self) {
        let query = self.search_query.to_lowercase();
        let indices: Vec<usize> = self
            .notes
            .iter()
            .enumerate()
            .filter(|(_, n)| n.title.to_lowercase().contains(&query))
            .map(|(i, _)| i)
            .collect();
        self.filtered_indices = Some(indices);
        if self.visible_count() == 0 {
            self.list_state.select(None);
        } else {
            self.list_state.select(Some(0));
        }
    }

    fn cancel_search(&mut self) {
        self.filtered_indices = None;
        self.search_query.clear();
        self.focus = Focus::List;
    }

    fn confirm_search(&mut self) {
        let real_index = self.list_state.selected().and_then(|i| {
            self.filtered_indices
                .as_ref()
                .and_then(|indices| indices.get(i).copied())
        });
        self.filtered_indices = None;
        self.search_query.clear();
        self.focus = Focus::List;
        if let Some(ri) = real_index {
            self.list_state.select(Some(ri));
        }
    }

    fn clear_expired_status(&mut self) {
        if let Some((_, time)) = &self.status_message {
            if time.elapsed() > Duration::from_secs(2) {
                self.status_message = None;
            }
        }
    }
}
use std::time::Duration;

fn db_path() -> String {
    std::env::var("JOTTS_DB_PATH").unwrap_or_else(|_| "jotts.sqlite".to_string())

            .map(|n| n.content.lines().count() as u16)
            .unwrap_or(0);

        terminal.draw(|frame| {
            let outer = Layout::vertical([Constraint::Min(1), Constraint::Length(1)])
                .split(frame.area());

            let chunks = Layout::horizontal([
                Constraint::Percentage(30),
                Constraint::Percentage(70),
            ])
            .split(outer[0]);

            let items: Vec<ListItem> = if let Some(indices) = &app.filtered_indices {
                indices
                    .iter()
                    .filter_map(|&i| app.notes.get(i))
                    .map(|n| ListItem::new(n.title.as_str()))
                    .collect()
            } else {
                app.notes
                    .iter()
                    .map(|n| ListItem::new(n.title.as_str()))
                    .collect()
            };

            let list_border_style = match app.focus {
                Focus::List | Focus::Search => Style::default().fg(Color::Yellow),
                _ => Style::default().fg(Color::DarkGray),
            };
            let content_border_style = match app.focus {
                Focus::Content => Style::default().fg(Color::Yellow),
                _ => Style::default().fg(Color::DarkGray),
            };
        terminal.draw(|frame| render::draw(frame, &mut app))?;

            let list = List::new(items)
                .block(
                    Block::default()
                        .title(" Notes ")
                        .borders(Borders::ALL)
                        .border_style(list_border_style),
                )
                .highlight_style(
                    Style::default()
                        .fg(Color::Yellow)
                        .add_modifier(Modifier::BOLD),
                )
                .highlight_symbol("▶ ");

            if matches!(app.focus, Focus::Search) {
                let search_split =
                    Layout::vertical([Constraint::Min(1), Constraint::Length(3)]).split(chunks[0]);

                let search_items: Vec<ListItem> = if let Some(indices) = &app.filtered_indices {
                    indices
                        .iter()
                        .filter_map(|&i| app.notes.get(i))
                        .map(|n| ListItem::new(n.title.as_str()))
                        .collect()
                } else {
                    app.notes
                        .iter()
                        .map(|n| ListItem::new(n.title.as_str()))
                        .collect()
                };
                let search_list = List::new(search_items)
                    .block(
                        Block::default()
                            .title(" Notes ")
                            .borders(Borders::ALL)
                            .border_style(list_border_style),
                    )
                    .highlight_style(
                        Style::default()
                            .fg(Color::Yellow)
                            .add_modifier(Modifier::BOLD),
                    )
                    .highlight_symbol("▶ ");
                frame.render_stateful_widget(search_list, search_split[0], &mut app.list_state);

                let search_input = Paragraph::new(app.search_query.as_str()).block(
                    Block::default()
                        .title(" Search ")
                        .borders(Borders::ALL)
                        .border_style(Style::default().fg(Color::Yellow)),
                );
                frame.render_widget(search_input, search_split[1]);

                let x = search_split[1].x + 1 + app.search_query.len() as u16;
                let y = search_split[1].y + 1;
                frame.set_cursor_position((x, y));
            } else {
                frame.render_stateful_widget(list, chunks[0], &mut app.list_state);
            }

            match app.focus {
                Focus::CreateTitle
                | Focus::CreateContent
                | Focus::EditTitle
                | Focus::EditContent => {
                    let form_title = match app.focus {
                        Focus::EditTitle | Focus::EditContent => " Edit Note ",
                        _ => " New Note ",
                    };
                    let create_block = Block::default()
                        .title(form_title)
                        .borders(Borders::ALL)
                        .border_style(Style::default().fg(Color::Yellow));

                    let inner = create_block.inner(chunks[1]);
                    frame.render_widget(create_block, chunks[1]);

                    let form_layout =
                        Layout::vertical([Constraint::Length(3), Constraint::Min(1)]).split(inner);

                    let title_style = match app.focus {
                        Focus::CreateTitle | Focus::EditTitle => Style::default().fg(Color::Yellow),
                        _ => Style::default().fg(Color::DarkGray),
                    };
                    let title_input = Paragraph::new(app.edit_title.as_str()).block(
                        Block::default()
                            .title(" Title ")
                            .borders(Borders::ALL)
                            .border_style(title_style),
                    );
                    frame.render_widget(title_input, form_layout[0]);

                    let content_style = match app.focus {
                        Focus::CreateContent | Focus::EditContent => {
                            Style::default().fg(Color::Yellow)
                        }
                        _ => Style::default().fg(Color::DarkGray),
                    };
                    let mut content_input = Paragraph::new(app.edit_content.as_str()).block(
                        Block::default()
                            .title(" Content ")
                            .borders(Borders::ALL)
                            .border_style(content_style),
                    );
                    if app.wrap_content {
                        content_input = content_input.wrap(Wrap { trim: false });
                    }
                    content_input = content_input.scroll((app.edit_scroll, 0));
                    frame.render_widget(content_input, form_layout[1]);

                    let content_inner =
                        Block::default().borders(Borders::ALL).inner(form_layout[1]);
                    let inner_width = content_inner.width;
                    let inner_height = content_inner.height;

                    match app.focus {
                        Focus::CreateTitle | Focus::EditTitle => {
                            let x = form_layout[0].x + 1 + app.edit_title.len() as u16;
                            let y = form_layout[0].y + 1;
                            frame.set_cursor_position((x, y));
                        }
                        Focus::CreateContent | Focus::EditContent => {
                            let (cx, cy) = if app.wrap_content {
                                app.cursor_position_wrapped(inner_width)
                            } else {
                                let last_line = app.edit_content.lines().last().unwrap_or("");
                                let line_count = app.edit_content.lines().count()
                                    + if app.edit_content.ends_with('\n') { 1 } else { 0 };
                                let y_offset = if line_count == 0 { 0 } else { line_count - 1 };
                                let col = if app.edit_content.ends_with('\n') {
                                    0
                                } else {
                                    last_line.len() as u16
                                };
                                (col, y_offset as u16)
                            };
                            app.auto_scroll_edit(cy, inner_height);
                            let screen_y = cy.saturating_sub(app.edit_scroll);
                            let x = content_inner.x + cx;
                            let y = content_inner.y + screen_y;
                            frame.set_cursor_position((x, y));
                        }
                        _ => {}
                    }
                }
                _ => {
                    let highlighted = match app.selected_note() {
                        Some(n) => app.highlighter.highlight_markdown(&n.content),
                        None => Text::raw(""),
                    };

                    let paragraph = Paragraph::new(highlighted)
                        .block(
                            Block::default()
                                .title(" Content ")
                                .borders(Borders::ALL)
                                .border_style(content_border_style),
                        )
                        .scroll((app.content_scroll, 0));

                    frame.render_widget(paragraph, chunks[1]);
                }
            }

            let hints = match app.focus {
                Focus::List => Line::from(vec![
                    Span::styled("j/k", Style::default().fg(Color::Yellow)),
                    Span::raw(": Navigate  "),
                    Span::styled("Enter", Style::default().fg(Color::Yellow)),
                    Span::raw(": View  "),
                    Span::styled("y", Style::default().fg(Color::Yellow)),
                    Span::raw(": Copy  "),
                    Span::styled("e", Style::default().fg(Color::Yellow)),
                    Span::raw(": Edit  "),
                    Span::styled("d", Style::default().fg(Color::Yellow)),
                    Span::raw(": Delete  "),
                    Span::styled("c", Style::default().fg(Color::Yellow)),
                    Span::raw(": Create  "),
                    Span::styled("/", Style::default().fg(Color::Yellow)),
                    Span::raw(": Search  "),
                    Span::styled("?", Style::default().fg(Color::Yellow)),
                    Span::raw(": Help  "),
                    Span::styled("q", Style::default().fg(Color::Yellow)),
                    Span::raw(": Quit"),
                ]),
                Focus::Content => Line::from(vec![
                    Span::styled("j/k", Style::default().fg(Color::Yellow)),
                    Span::raw(": Scroll  "),
                    Span::styled("y", Style::default().fg(Color::Yellow)),
                    Span::raw(": Copy  "),
                    Span::styled("e", Style::default().fg(Color::Yellow)),
                    Span::raw(": Edit  "),
                    Span::styled("Esc", Style::default().fg(Color::Yellow)),
                    Span::raw(": Back  "),
                    Span::styled("?", Style::default().fg(Color::Yellow)),
                    Span::raw(": Help"),
                ]),
                Focus::CreateTitle
                | Focus::CreateContent
                | Focus::EditTitle
                | Focus::EditContent => Line::from(vec![
                    Span::styled("Tab", Style::default().fg(Color::Yellow)),
                    Span::raw(": Switch field  "),
                    Span::styled("Ctrl+S", Style::default().fg(Color::Yellow)),
                    Span::raw(": Save  "),
                    Span::styled("Ctrl+W", Style::default().fg(Color::Yellow)),
                    Span::raw(": Wrap  "),
                    Span::styled("Esc", Style::default().fg(Color::Yellow)),
                    Span::raw(": Cancel"),
                ]),
                Focus::Search => Line::from(vec![
                    Span::styled("Type", Style::default().fg(Color::Yellow)),
                    Span::raw(": Filter  "),
                    Span::styled("Enter", Style::default().fg(Color::Yellow)),
                    Span::raw(": Select  "),
                    Span::styled("Esc", Style::default().fg(Color::Yellow)),
                    Span::raw(": Cancel"),
                ]),
            };
            frame.render_widget(Paragraph::new(hints), outer[1]);

            if let Some((msg, _)) = &app.status_message {
                let area = frame.area();
                let msg_width = (msg.len() as u16 + 4).max(20).min(area.width.saturating_sub(4));
                let popup_area = ratatui::layout::Rect {
                    x: (area.width.saturating_sub(msg_width)) / 2,
                    y: (area.height.saturating_sub(3)) / 2,
                    width: msg_width,
                    height: 3,
                };
                Clear.render(popup_area, frame.buffer_mut());
                let status_popup = Paragraph::new(Line::from(msg.as_str()))
                    .style(Style::default().fg(Color::Green).add_modifier(Modifier::BOLD))
                    .alignment(Alignment::Center)
                    .block(
                        Block::default()
                            .borders(Borders::ALL)
                            .border_style(Style::default().fg(Color::Green)),
                    );
                frame.render_widget(status_popup, popup_area);
            }

            if app.confirm_delete {
                let delete_msg = match app.selected_note() {
                    Some(n) => format!("Delete {}? (y/n)", n.title),
                    None => "Delete note? (y/n)".to_string(),
                };
                let area = frame.area();
                let msg_width = (delete_msg.len() as u16 + 4).max(24).min(area.width.saturating_sub(4));
                let popup_area = ratatui::layout::Rect {
                    x: (area.width.saturating_sub(msg_width)) / 2,
                    y: (area.height.saturating_sub(3)) / 2,
                    width: msg_width,
                    height: 3,
                };
                Clear.render(popup_area, frame.buffer_mut());
                let confirm_popup = Paragraph::new(Line::from(delete_msg))
                    .style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))
                    .alignment(Alignment::Center)
                    .block(
                        Block::default()
                            .borders(Borders::ALL)
                            .border_style(Style::default().fg(Color::Red)),
                    );
                frame.render_widget(confirm_popup, popup_area);
            }

            if app.show_help {
                let area = frame.area();
                let popup_width = 34u16.min(area.width.saturating_sub(4));
                let popup_height = 21u16.min(area.height.saturating_sub(4));
                let popup_area = ratatui::layout::Rect {
                    x: (area.width.saturating_sub(popup_width)) / 2,
                    y: (area.height.saturating_sub(popup_height)) / 2,
                    width: popup_width,
                    height: popup_height,
                };

                let mut help_lines = vec![
                    Line::from(""),
                    Line::from(vec![
                        Span::styled("  j/↓  ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Move down / Scroll down"),
                    ]),
                    Line::from(vec![
                        Span::styled("  k/↑  ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Move up / Scroll up"),
                    ]),
                    Line::from(vec![
                        Span::styled("  Enter", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("  Focus content pane"),
                    ]),
                    Line::from(vec![
                        Span::styled("  Esc  ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Back / Quit"),
                    ]),
                    Line::from(vec![
                        Span::styled("  y    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Copy note"),
                    ]),
                    Line::from(vec![
                        Span::styled("  Y    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Copy link"),
                    ]),
                    Line::from(vec![
                        Span::styled("  o    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Open in browser"),
                    ]),
                    Line::from(vec![
                        Span::styled("  d    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Delete note"),
                    ]),
                    Line::from(vec![
                        Span::styled("  c    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Create note"),
                    ]),
                    Line::from(vec![
                        Span::styled("  e    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Edit note"),
                    ]),
                    Line::from(vec![
                        Span::styled("  E    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Edit in $EDITOR"),
                    ]),
                    Line::from(vec![
                        Span::styled("  /    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Search notes"),
                    ]),
                    Line::from(vec![
                        Span::styled("  ^W   ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Toggle word wrap (edit)"),
                    ]),
                ];

                if app.is_remote {
                    help_lines.push(Line::from(vec![
                        Span::styled("  r    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Refresh notes"),
                    ]));
                }

                help_lines.extend([
                    Line::from(vec![
                        Span::styled("  q    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Quit"),
                    ]),
                    Line::from(vec![
                        Span::styled("  ?    ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
                        Span::raw("Toggle this help"),
                    ]),
                    Line::from(""),
                    Line::from(Span::styled(
                        "  Press any key to close",
                        Style::default().fg(Color::DarkGray),
                    )),
                ]);

                let help_text = Text::from(help_lines);

                Clear.render(popup_area, frame.buffer_mut());
                let help = Paragraph::new(help_text).block(
                    Block::default()
                        .title(" Keybindings ")
                        .borders(Borders::ALL)
                        .border_style(Style::default().fg(Color::Yellow)),
                );
                frame.render_widget(help, popup_area);
            }
        })?;

        if event::poll(Duration::from_millis(100))? {
            if let Event::Key(key) = event::read()? {
                if app.show_help {
                    app.show_help = false;
                } else if app.status_message.is_some() {
                    app.status_message = None;
                } else if app.confirm_delete {
                    if key.code == KeyCode::Char('y') {
                        app.delete_selected(backend);
                    }
                    app.confirm_delete = false;
                } else {
                    match app.focus {
                        Focus::List => match key.code {
                            KeyCode::Char('q') | KeyCode::Esc => app.should_quit = true,
                            KeyCode::Char('j') | KeyCode::Down => app.move_down(),
                            KeyCode::Char('k') | KeyCode::Up => app.move_up(),
                            KeyCode::Char('y') => app.copy_selected(),
                            KeyCode::Char('Y') => app.copy_link(),
                            KeyCode::Char('d') => app.confirm_delete = true,
                            KeyCode::Char('c') => app.start_create(),
                            KeyCode::Char('e') => app.start_edit(),
                            KeyCode::Char('E') => {
                                edit_in_external_editor(terminal, &mut app, backend)?
                            }
                            KeyCode::Char('/') => app.start_search(),
                            KeyCode::Char('o') => app.open_in_browser(),
                            KeyCode::Char('r') if app.is_remote => app.refresh(backend),
                            KeyCode::Char('?') => app.show_help = true,
                            KeyCode::Enter | KeyCode::Char('l') => {
                                if app.selected_note().is_some() {
                                    app.focus = Focus::Content;
                                }
                            }
                            _ => {}
                        },
                        Focus::Content => match key.code {
                            KeyCode::Char(' ')
                            | KeyCode::Esc
                            | KeyCode::Char('q')
                            | KeyCode::Char('h') => {
                                app.focus = Focus::List;
                            }
                            KeyCode::Char('j') | KeyCode::Down => {
                                app.scroll_down(content_line_count);
                            }
                            KeyCode::Char('k') | KeyCode::Up => app.scroll_up(),
                            KeyCode::Char('y') => app.copy_selected(),
                            KeyCode::Char('Y') => app.copy_link(),
                            KeyCode::Char('e') => app.start_edit(),
                            KeyCode::Char('E') => {
                                edit_in_external_editor(terminal, &mut app, backend)?
                            }
                            KeyCode::Char('o') => app.open_in_browser(),
                            KeyCode::Char('?') => app.show_help = true,
                            _ => {}
                        },
                        Focus::CreateTitle => {
                            if key.modifiers.contains(KeyModifiers::CONTROL)
                                && key.code == KeyCode::Char('s')
                            {
                                app.save_create(backend);
                            } else {
                                match key.code {
                                    KeyCode::Esc => app.cancel_create(),
                                    KeyCode::Enter | KeyCode::Tab => {
                                        app.focus = Focus::CreateContent
                                    }
                                    KeyCode::Backspace => {
                                        app.edit_title.pop();
                                    }
                                    KeyCode::Char(c) => app.edit_title.push(c),
                                    _ => {}
                                }
                            }
                        }
                        Focus::CreateContent => {
                            if key.modifiers.contains(KeyModifiers::CONTROL) {
                                match key.code {
                                    KeyCode::Char('s') => app.save_create(backend),
                                    KeyCode::Char('w') => {
                                        app.wrap_content = !app.wrap_content;
                                        app.edit_scroll = 0;
                                    }
                                    _ => {}
                                }
                            } else {
                                match key.code {
                                    KeyCode::Esc => app.cancel_create(),
                                    KeyCode::Tab => app.focus = Focus::CreateTitle,
                                    KeyCode::Enter => app.edit_content.push('\n'),
                                    KeyCode::Backspace => {
                                        app.edit_content.pop();
                                    }
                                    KeyCode::Char(c) => app.edit_content.push(c),
                                    _ => {}
                                }
                            }
                        }
                        Focus::EditTitle => {
                            if key.modifiers.contains(KeyModifiers::CONTROL)
                                && key.code == KeyCode::Char('s')
                            {
                                app.save_edit(backend);
                            } else {
                                match key.code {
                                    KeyCode::Esc => app.cancel_edit(),
                                    KeyCode::Enter | KeyCode::Tab => {
                                        app.focus = Focus::EditContent
                                    }
                                    KeyCode::Backspace => {
                                        app.edit_title.pop();
                                    }
                                    KeyCode::Char(c) => app.edit_title.push(c),
                                    _ => {}
                                }
                            }
                        }
                        Focus::EditContent => {
                            if key.modifiers.contains(KeyModifiers::CONTROL) {
                                match key.code {
                                    KeyCode::Char('s') => app.save_edit(backend),
                                    KeyCode::Char('w') => {
                                        app.wrap_content = !app.wrap_content;
                                        app.edit_scroll = 0;
                                    }
                                    _ => {}
                                }
                            } else {
                                match key.code {
                                    KeyCode::Esc => app.cancel_edit(),
                                    KeyCode::Tab => app.focus = Focus::EditTitle,
                                    KeyCode::Enter => app.edit_content.push('\n'),
                                    KeyCode::Backspace => {
                                        app.edit_content.pop();
                                    }
                                    KeyCode::Char(c) => app.edit_content.push(c),
                                    _ => {}
                                }
                            }
                        }
                        Focus::Search => match key.code {
                            KeyCode::Esc => app.cancel_search(),
                            KeyCode::Enter => app.confirm_search(),
                            KeyCode::Backspace => {
                                app.search_query.pop();
                                app.update_search_filter();
                            }
                            KeyCode::Char(c) => {
                                app.search_query.push(c);
                                app.update_search_filter();
                            }
                            _ => {}
                        },
                    }
                }
            }
        if event::poll(Duration::from_millis(100))?
            && let Event::Key(key) = event::read()?
        {
            events::handle_key(terminal, &mut app, backend, key, content_line_count)?;
        }
    }


apps/jotts/src/tui/app.rs (added) +413 −0

1	+	use crate::backend::Backend;
2	+	use crate::db::Note;
3	+	use crate::highlight::Highlighter;
4	+	use arboard::Clipboard;
5	+	use ratatui::widgets::ListState;
6	+	use std::time::{Duration, Instant};
7	+
8	+	pub(super) enum Focus {
9	+	List,
10	+	Content,
11	+	CreateTitle,
12	+	CreateContent,
13	+	EditTitle,
14	+	EditContent,
15	+	Search,
16	+	}
17	+
18	+	pub(super) struct App {
19	+	pub(super) notes: Vec<Note>,
20	+	pub(super) list_state: ListState,
21	+	pub(super) should_quit: bool,
22	+	pub(super) status_message: Option<(String, Instant)>,
23	+	pub(super) focus: Focus,
24	+	pub(super) content_scroll: u16,
25	+	pub(super) show_help: bool,
26	+	pub(super) confirm_delete: bool,
27	+	pub(super) highlighter: Highlighter,
28	+	pub(super) edit_title: String,
29	+	pub(super) edit_content: String,
30	+	pub(super) edit_short_id: Option<String>,
31	+	pub(super) search_query: String,
32	+	pub(super) filtered_indices: Option<Vec<usize>>,
33	+	pub(super) is_remote: bool,
34	+	pub(super) remote_url: Option<String>,
35	+	pub(super) wrap_content: bool,
36	+	pub(super) edit_scroll: u16,
37	+	}
38	+
39	+	impl App {
40	+	pub(super) fn new(notes: Vec<Note>, is_remote: bool, remote_url: Option<String>) -> Self {
41	+	let mut list_state = ListState::default();
42	+	if !notes.is_empty() {
43	+	list_state.select(Some(0));
44	+	}
45	+	Self {
46	+	notes,
47	+	list_state,
48	+	should_quit: false,
49	+	status_message: None,
50	+	focus: Focus::List,
51	+	content_scroll: 0,
52	+	show_help: false,
53	+	confirm_delete: false,
54	+	highlighter: Highlighter::new(),
55	+	edit_title: String::new(),
56	+	edit_content: String::new(),
57	+	edit_short_id: None,
58	+	search_query: String::new(),
59	+	filtered_indices: None,
60	+	is_remote,
61	+	remote_url,
62	+	wrap_content: true,
63	+	edit_scroll: 0,
64	+	}
65	+	}
66	+
67	+	pub(super) fn selected_note(&self) -> Option<&Note> {
68	+	self.list_state.selected().and_then(\|i\| {
69	+	if let Some(indices) = &self.filtered_indices {
70	+	indices.get(i).and_then(\|&real\| self.notes.get(real))
71	+	} else {
72	+	self.notes.get(i)
73	+	}
74	+	})
75	+	}
76	+
77	+	pub(super) fn visible_count(&self) -> usize {
78	+	match &self.filtered_indices {
79	+	Some(indices) => indices.len(),
80	+	None => self.notes.len(),
81	+	}
82	+	}
83	+
84	+	pub(super) fn move_up(&mut self) {
85	+	let count = self.visible_count();
86	+	if count == 0 {
87	+	return;
88	+	}
89	+	let i = match self.list_state.selected() {
90	+	Some(i) if i > 0 => i - 1,
91	+	Some(_) => count - 1,
92	+	None => 0,
93	+	};
94	+	self.list_state.select(Some(i));
95	+	self.content_scroll = 0;
96	+	}
97	+
98	+	pub(super) fn move_down(&mut self) {
99	+	let count = self.visible_count();
100	+	if count == 0 {
101	+	return;
102	+	}
103	+	let i = match self.list_state.selected() {
104	+	Some(i) if i < count - 1 => i + 1,
105	+	Some(_) => 0,
106	+	None => 0,
107	+	};
108	+	self.list_state.select(Some(i));
109	+	self.content_scroll = 0;
110	+	}
111	+
112	+	pub(super) fn scroll_up(&mut self) {
113	+	self.content_scroll = self.content_scroll.saturating_sub(1);
114	+	}
115	+
116	+	pub(super) fn scroll_down(&mut self, max_lines: u16) {
117	+	if self.content_scroll < max_lines {
118	+	self.content_scroll += 1;
119	+	}
120	+	}
121	+
122	+	pub(super) fn copy_selected(&mut self) {
123	+	if let Some(note) = self.selected_note() {
124	+	if let Ok(mut clipboard) = Clipboard::new() {
125	+	let _ = clipboard.set_text(&note.content);
126	+	self.status_message = Some(("Copied!".to_string(), Instant::now()));
127	+	}
128	+	}
129	+	}
130	+
131	+	pub(super) fn copy_link(&mut self) {
132	+	match &self.remote_url {
133	+	Some(url) => {
134	+	if let Some(note) = self.selected_note() {
135	+	let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);
136	+	if let Ok(mut clipboard) = Clipboard::new() {
137	+	let _ = clipboard.set_text(&link);
138	+	self.status_message =
139	+	Some(("Link copied!".to_string(), Instant::now()));
140	+	}
141	+	}
142	+	}
143	+	None => {
144	+	self.status_message =
145	+	Some(("No remote URL configured".to_string(), Instant::now()));
146	+	}
147	+	}
148	+	}
149	+
150	+	pub(super) fn open_in_browser(&mut self) {
151	+	match &self.remote_url {
152	+	Some(url) => {
153	+	if let Some(note) = self.selected_note() {
154	+	let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);
155	+	if let Err(e) = open::that(&link) {
156	+	self.status_message =
157	+	Some((format!("Failed to open browser: {}", e), Instant::now()));
158	+	} else {
159	+	self.status_message =
160	+	Some(("Opened in browser!".to_string(), Instant::now()));
161	+	}
162	+	}
163	+	}
164	+	None => {
165	+	self.status_message =
166	+	Some(("No remote URL configured".to_string(), Instant::now()));
167	+	}
168	+	}
169	+	}
170	+
171	+	pub(super) fn delete_selected(&mut self, backend: &Backend) {
172	+	if let Some(selected_index) = self.list_state.selected() {
173	+	let real_index = if let Some(indices) = &self.filtered_indices {
174	+	match indices.get(selected_index) {
175	+	Some(&ri) => ri,
176	+	None => return,
177	+	}
178	+	} else {
179	+	selected_index
180	+	};
181	+	if let Some(note) = self.notes.get(real_index) {
182	+	let short_id = note.short_id.clone();
183	+	match backend.delete_note(&short_id) {
184	+	Ok(true) => {
185	+	self.notes.remove(real_index);
186	+	if self.filtered_indices.is_some() {
187	+	self.update_search_filter();
188	+	}
189	+	let count = self.visible_count();
190	+	if count == 0 {
191	+	self.list_state.select(None);
192	+	} else if selected_index >= count {
193	+	self.list_state.select(Some(count - 1));
194	+	} else {
195	+	self.list_state.select(Some(selected_index));
196	+	}
197	+	self.status_message = Some(("Deleted!".to_string(), Instant::now()));
198	+	}
199	+	Ok(false) => {
200	+	self.status_message =
201	+	Some(("Note not found".to_string(), Instant::now()));
202	+	}
203	+	Err(e) => {
204	+	self.status_message = Some((e.to_string(), Instant::now()));
205	+	}
206	+	}
207	+	}
208	+	}
209	+	}
210	+
211	+	pub(super) fn refresh(&mut self, backend: &Backend) {
212	+	match backend.list_notes() {
213	+	Ok(notes) => {
214	+	self.notes = notes;
215	+	self.filtered_indices = None;
216	+	self.search_query.clear();
217	+	if self.notes.is_empty() {
218	+	self.list_state.select(None);
219	+	} else {
220	+	let idx = self.list_state.selected().unwrap_or(0);
221	+	if idx >= self.notes.len() {
222	+	self.list_state.select(Some(self.notes.len() - 1));
223	+	}
224	+	}
225	+	self.status_message = Some(("Refreshed!".to_string(), Instant::now()));
226	+	}
227	+	Err(e) => {
228	+	self.status_message = Some((e.to_string(), Instant::now()));
229	+	}
230	+	}
231	+	}
232	+
233	+	pub(super) fn cursor_position_wrapped(&self, width: u16) -> (u16, u16) {
234	+	let w = width as usize;
235	+	if w == 0 {
236	+	return (0, 0);
237	+	}
238	+	let text = &self.edit_content;
239	+	let mut visual_row: usize = 0;
240	+	let lines: Vec<&str> = if text.is_empty() {
241	+	vec![""]
242	+	} else {
243	+	text.split('\n').collect()
244	+	};
245	+	let last_idx = lines.len() - 1;
246	+	for (i, line) in lines.iter().enumerate() {
247	+	let line_len = line.len();
248	+	let wrapped_lines = if line_len == 0 {
249	+	1
250	+	} else {
251	+	(line_len + w - 1) / w
252	+	};
253	+	if i < last_idx {
254	+	visual_row += wrapped_lines;
255	+	} else {
256	+	let cursor_col = if text.ends_with('\n') { 0 } else { line_len };
257	+	let extra_rows = cursor_col / w;
258	+	let col = cursor_col % w;
259	+	visual_row += extra_rows;
260	+	return (col as u16, visual_row as u16);
261	+	}
262	+	}
263	+	(0, visual_row as u16)
264	+	}
265	+
266	+	pub(super) fn auto_scroll_edit(&mut self, cursor_visual_row: u16, visible_height: u16) {
267	+	if visible_height == 0 {
268	+	return;
269	+	}
270	+	if cursor_visual_row < self.edit_scroll {
271	+	self.edit_scroll = cursor_visual_row;
272	+	} else if cursor_visual_row >= self.edit_scroll + visible_height {
273	+	self.edit_scroll = cursor_visual_row - visible_height + 1;
274	+	}
275	+	}
276	+
277	+	pub(super) fn start_create(&mut self) {
278	+	self.edit_title.clear();
279	+	self.edit_content.clear();
280	+	self.edit_scroll = 0;
281	+	self.focus = Focus::CreateTitle;
282	+	}
283	+
284	+	pub(super) fn save_create(&mut self, backend: &Backend) {
285	+	if self.edit_title.trim().is_empty() {
286	+	self.status_message = Some(("Title cannot be empty".to_string(), Instant::now()));
287	+	return;
288	+	}
289	+	match backend.create_note(&self.edit_title, &self.edit_content) {
290	+	Ok(note) => {
291	+	self.notes.insert(0, note);
292	+	self.list_state.select(Some(0));
293	+	self.filtered_indices = None;
294	+	self.search_query.clear();
295	+	self.status_message = Some(("Created!".to_string(), Instant::now()));
296	+	self.focus = Focus::List;
297	+	self.edit_title.clear();
298	+	self.edit_content.clear();
299	+	}
300	+	Err(e) => {
301	+	self.status_message = Some((e.to_string(), Instant::now()));
302	+	}
303	+	}
304	+	}
305	+
306	+	pub(super) fn cancel_create(&mut self) {
307	+	self.edit_title.clear();
308	+	self.edit_content.clear();
309	+	self.focus = Focus::List;
310	+	}
311	+
312	+	pub(super) fn start_edit(&mut self) {
313	+	let data = self
314	+	.selected_note()
315	+	.map(\|n\| (n.title.clone(), n.content.clone(), n.short_id.clone()));
316	+	if let Some((title, content, short_id)) = data {
317	+	self.edit_title = title;
318	+	self.edit_content = content;
319	+	self.edit_short_id = Some(short_id);
320	+	self.edit_scroll = 0;
321	+	self.focus = Focus::EditTitle;
322	+	}
323	+	}
324	+
325	+	pub(super) fn save_edit(&mut self, backend: &Backend) {
326	+	if self.edit_title.trim().is_empty() {
327	+	self.status_message = Some(("Title cannot be empty".to_string(), Instant::now()));
328	+	return;
329	+	}
330	+	let short_id = match &self.edit_short_id {
331	+	Some(id) => id.clone(),
332	+	None => return,
333	+	};
334	+	match backend.update_note(&short_id, &self.edit_title, &self.edit_content) {
335	+	Ok(Some(updated)) => {
336	+	if let Some(pos) = self.notes.iter().position(\|n\| n.short_id == short_id) {
337	+	self.notes[pos] = updated;
338	+	}
339	+	self.status_message = Some(("Updated!".to_string(), Instant::now()));
340	+	self.focus = Focus::List;
341	+	self.edit_title.clear();
342	+	self.edit_content.clear();
343	+	self.edit_short_id = None;
344	+	}
345	+	Ok(None) => {
346	+	self.status_message = Some(("Note not found".to_string(), Instant::now()));
347	+	}
348	+	Err(e) => {
349	+	self.status_message = Some((e.to_string(), Instant::now()));
350	+	}
351	+	}
352	+	}
353	+
354	+	pub(super) fn cancel_edit(&mut self) {
355	+	self.edit_title.clear();
356	+	self.edit_content.clear();
357	+	self.edit_short_id = None;
358	+	self.focus = Focus::List;
359	+	}
360	+
361	+	pub(super) fn start_search(&mut self) {
362	+	self.search_query.clear();
363	+	self.filtered_indices = Some((0..self.notes.len()).collect());
364	+	self.focus = Focus::Search;
365	+	self.list_state
366	+	.select(if self.notes.is_empty() { None } else { Some(0) });
367	+	}
368	+
369	+	pub(super) fn update_search_filter(&mut self) {
370	+	let query = self.search_query.to_lowercase();
371	+	let indices: Vec<usize> = self
372	+	.notes
373	+	.iter()
374	+	.enumerate()
375	+	.filter(\|(_, n)\| n.title.to_lowercase().contains(&query))
376	+	.map(\|(i, _)\| i)
377	+	.collect();
378	+	self.filtered_indices = Some(indices);
379	+	if self.visible_count() == 0 {
380	+	self.list_state.select(None);
381	+	} else {
382	+	self.list_state.select(Some(0));
383	+	}
384	+	}
385	+
386	+	pub(super) fn cancel_search(&mut self) {
387	+	self.filtered_indices = None;
388	+	self.search_query.clear();
389	+	self.focus = Focus::List;
390	+	}
391	+
392	+	pub(super) fn confirm_search(&mut self) {
393	+	let real_index = self.list_state.selected().and_then(\|i\| {
394	+	self.filtered_indices
395	+	.as_ref()
396	+	.and_then(\|indices\| indices.get(i).copied())
397	+	});
398	+	self.filtered_indices = None;
399	+	self.search_query.clear();
400	+	self.focus = Focus::List;
401	+	if let Some(ri) = real_index {
402	+	self.list_state.select(Some(ri));
403	+	}
404	+	}
405	+
406	+	pub(super) fn clear_expired_status(&mut self) {
407	+	if let Some((_, time)) = &self.status_message {
408	+	if time.elapsed() > Duration::from_secs(2) {
409	+	self.status_message = None;
410	+	}
411	+	}
412	+	}
413	+	}

apps/jotts/src/tui/editor.rs (added) +69 −0

1	+	use super::app::App;
2	+	use crate::backend::Backend;
3	+	use ratatui::DefaultTerminal;
4	+	use std::time::Instant;
5	+
6	+	pub(super) fn edit_in_external_editor(
7	+	terminal: &mut DefaultTerminal,
8	+	app: &mut App,
9	+	backend: &Backend,
10	+	) -> Result<(), Box<dyn std::error::Error>> {
11	+	let (short_id, title, content) = match app.selected_note() {
12	+	Some(n) => (n.short_id.clone(), n.title.clone(), n.content.clone()),
13	+	None => return Ok(()),
14	+	};
15	+
16	+	let editor = match std::env::var("EDITOR") {
17	+	Ok(e) if !e.trim().is_empty() => e,
18	+	_ => {
19	+	app.status_message = Some(("EDITOR env not set".to_string(), Instant::now()));
20	+	return Ok(());
21	+	}
22	+	};
23	+
24	+	let mut path = std::env::temp_dir();
25	+	path.push(format!("jotts-{}.md", short_id));
26	+	std::fs::write(&path, &content)?;
27	+
28	+	ratatui::restore();
29	+
30	+	let status = std::process::Command::new(&editor).arg(&path).status();
31	+
32	+	*terminal = ratatui::init();
33	+	terminal.clear()?;
34	+
35	+	match status {
36	+	Ok(s) if s.success() => {
37	+	let new_content = std::fs::read_to_string(&path)?;
38	+	let _ = std::fs::remove_file(&path);
39	+	if new_content == content {
40	+	app.status_message = Some(("No changes".to_string(), Instant::now()));
41	+	return Ok(());
42	+	}
43	+	match backend.update_note(&short_id, &title, &new_content) {
44	+	Ok(Some(updated)) => {
45	+	if let Some(pos) = app.notes.iter().position(\|n\| n.short_id == short_id) {
46	+	app.notes[pos] = updated;
47	+	}
48	+	app.status_message = Some(("Updated!".to_string(), Instant::now()));
49	+	}
50	+	Ok(None) => {
51	+	app.status_message = Some(("Note not found".to_string(), Instant::now()));
52	+	}
53	+	Err(e) => {
54	+	app.status_message = Some((e.to_string(), Instant::now()));
55	+	}
56	+	}
57	+	}
58	+	Ok(_) => {
59	+	let _ = std::fs::remove_file(&path);
60	+	app.status_message = Some(("Editor exited non-zero".to_string(), Instant::now()));
61	+	}
62	+	Err(e) => {
63	+	let _ = std::fs::remove_file(&path);
64	+	app.status_message =
65	+	Some((format!("Failed to launch editor: {}", e), Instant::now()));
66	+	}
67	+	}
68	+	Ok(())
69	+	}

apps/jotts/src/tui/events.rs (added) +160 −0

1	+	use super::app::{App, Focus};
2	+	use super::editor::edit_in_external_editor;
3	+	use crate::backend::Backend;
4	+	use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
5	+	use ratatui::DefaultTerminal;
6	+
7	+	pub(super) fn handle_key(
8	+	terminal: &mut DefaultTerminal,
9	+	app: &mut App,
10	+	backend: &Backend,
11	+	key: KeyEvent,
12	+	content_line_count: u16,
13	+	) -> Result<(), Box<dyn std::error::Error>> {
14	+	if app.show_help {
15	+	app.show_help = false;
16	+	return Ok(());
17	+	}
18	+	if app.status_message.is_some() {
19	+	app.status_message = None;
20	+	return Ok(());
21	+	}
22	+	if app.confirm_delete {
23	+	if key.code == KeyCode::Char('y') {
24	+	app.delete_selected(backend);
25	+	}
26	+	app.confirm_delete = false;
27	+	return Ok(());
28	+	}
29	+
30	+	match app.focus {
31	+	Focus::List => match key.code {
32	+	KeyCode::Char('q') \| KeyCode::Esc => app.should_quit = true,
33	+	KeyCode::Char('j') \| KeyCode::Down => app.move_down(),
34	+	KeyCode::Char('k') \| KeyCode::Up => app.move_up(),
35	+	KeyCode::Char('y') => app.copy_selected(),
36	+	KeyCode::Char('Y') => app.copy_link(),
37	+	KeyCode::Char('d') => app.confirm_delete = true,
38	+	KeyCode::Char('c') => app.start_create(),
39	+	KeyCode::Char('e') => app.start_edit(),
40	+	KeyCode::Char('E') => edit_in_external_editor(terminal, app, backend)?,
41	+	KeyCode::Char('/') => app.start_search(),
42	+	KeyCode::Char('o') => app.open_in_browser(),
43	+	KeyCode::Char('r') if app.is_remote => app.refresh(backend),
44	+	KeyCode::Char('?') => app.show_help = true,
45	+	KeyCode::Enter \| KeyCode::Char('l') => {
46	+	if app.selected_note().is_some() {
47	+	app.focus = Focus::Content;
48	+	}
49	+	}
50	+	_ => {}
51	+	},
52	+	Focus::Content => match key.code {
53	+	KeyCode::Char(' ')
54	+	\| KeyCode::Esc
55	+	\| KeyCode::Char('q')
56	+	\| KeyCode::Char('h') => {
57	+	app.focus = Focus::List;
58	+	}
59	+	KeyCode::Char('j') \| KeyCode::Down => app.scroll_down(content_line_count),
60	+	KeyCode::Char('k') \| KeyCode::Up => app.scroll_up(),
61	+	KeyCode::Char('y') => app.copy_selected(),
62	+	KeyCode::Char('Y') => app.copy_link(),
63	+	KeyCode::Char('e') => app.start_edit(),
64	+	KeyCode::Char('E') => edit_in_external_editor(terminal, app, backend)?,
65	+	KeyCode::Char('o') => app.open_in_browser(),
66	+	KeyCode::Char('?') => app.show_help = true,
67	+	_ => {}
68	+	},
69	+	Focus::CreateTitle => {
70	+	if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('s') {
71	+	app.save_create(backend);
72	+	} else {
73	+	match key.code {
74	+	KeyCode::Esc => app.cancel_create(),
75	+	KeyCode::Enter \| KeyCode::Tab => app.focus = Focus::CreateContent,
76	+	KeyCode::Backspace => {
77	+	app.edit_title.pop();
78	+	}
79	+	KeyCode::Char(c) => app.edit_title.push(c),
80	+	_ => {}
81	+	}
82	+	}
83	+	}
84	+	Focus::CreateContent => {
85	+	if key.modifiers.contains(KeyModifiers::CONTROL) {
86	+	match key.code {
87	+	KeyCode::Char('s') => app.save_create(backend),
88	+	KeyCode::Char('w') => {
89	+	app.wrap_content = !app.wrap_content;
90	+	app.edit_scroll = 0;
91	+	}
92	+	_ => {}
93	+	}
94	+	} else {
95	+	match key.code {
96	+	KeyCode::Esc => app.cancel_create(),
97	+	KeyCode::Tab => app.focus = Focus::CreateTitle,
98	+	KeyCode::Enter => app.edit_content.push('\n'),
99	+	KeyCode::Backspace => {
100	+	app.edit_content.pop();
101	+	}
102	+	KeyCode::Char(c) => app.edit_content.push(c),
103	+	_ => {}
104	+	}
105	+	}
106	+	}
107	+	Focus::EditTitle => {
108	+	if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('s') {
109	+	app.save_edit(backend);
110	+	} else {
111	+	match key.code {
112	+	KeyCode::Esc => app.cancel_edit(),
113	+	KeyCode::Enter \| KeyCode::Tab => app.focus = Focus::EditContent,
114	+	KeyCode::Backspace => {
115	+	app.edit_title.pop();
116	+	}
117	+	KeyCode::Char(c) => app.edit_title.push(c),
118	+	_ => {}
119	+	}
120	+	}
121	+	}
122	+	Focus::EditContent => {
123	+	if key.modifiers.contains(KeyModifiers::CONTROL) {
124	+	match key.code {
125	+	KeyCode::Char('s') => app.save_edit(backend),
126	+	KeyCode::Char('w') => {
127	+	app.wrap_content = !app.wrap_content;
128	+	app.edit_scroll = 0;
129	+	}
130	+	_ => {}
131	+	}
132	+	} else {
133	+	match key.code {
134	+	KeyCode::Esc => app.cancel_edit(),
135	+	KeyCode::Tab => app.focus = Focus::EditTitle,
136	+	KeyCode::Enter => app.edit_content.push('\n'),
137	+	KeyCode::Backspace => {
138	+	app.edit_content.pop();
139	+	}
140	+	KeyCode::Char(c) => app.edit_content.push(c),
141	+	_ => {}
142	+	}
143	+	}
144	+	}
145	+	Focus::Search => match key.code {
146	+	KeyCode::Esc => app.cancel_search(),
147	+	KeyCode::Enter => app.confirm_search(),
148	+	KeyCode::Backspace => {
149	+	app.search_query.pop();
150	+	app.update_search_filter();
151	+	}
152	+	KeyCode::Char(c) => {
153	+	app.search_query.push(c);
154	+	app.update_search_filter();
155	+	}
156	+	_ => {}
157	+	},
158	+	}
159	+	Ok(())
160	+	}

apps/jotts/src/tui/render.rs (added) +399 −0

1	+	use super::app::{App, Focus};
2	+	use ratatui::{
3	+	Frame,
4	+	layout::{Alignment, Constraint, Layout},
5	+	style::{Color, Modifier, Style},
6	+	text::{Line, Span, Text},
7	+	widgets::{Block, Borders, Clear, List, ListItem, Paragraph, Widget, Wrap},
8	+	};
9	+
10	+	pub(super) fn draw(frame: &mut Frame, app: &mut App) {
11	+	let outer = Layout::vertical([Constraint::Min(1), Constraint::Length(1)]).split(frame.area());
12	+
13	+	let chunks =
14	+	Layout::horizontal([Constraint::Percentage(30), Constraint::Percentage(70)]).split(outer[0]);
15	+
16	+	let items: Vec<ListItem> = if let Some(indices) = &app.filtered_indices {
17	+	indices
18	+	.iter()
19	+	.filter_map(\|&i\| app.notes.get(i))
20	+	.map(\|n\| ListItem::new(n.title.as_str()))
21	+	.collect()
22	+	} else {
23	+	app.notes
24	+	.iter()
25	+	.map(\|n\| ListItem::new(n.title.as_str()))
26	+	.collect()
27	+	};
28	+
29	+	let list_border_style = match app.focus {
30	+	Focus::List \| Focus::Search => Style::default().fg(Color::Yellow),
31	+	_ => Style::default().fg(Color::DarkGray),
32	+	};
33	+	let content_border_style = match app.focus {
34	+	Focus::Content => Style::default().fg(Color::Yellow),
35	+	_ => Style::default().fg(Color::DarkGray),
36	+	};
37	+
38	+	let list = List::new(items)
39	+	.block(
40	+	Block::default()
41	+	.title(" Notes ")
42	+	.borders(Borders::ALL)
43	+	.border_style(list_border_style),
44	+	)
45	+	.highlight_style(
46	+	Style::default()
47	+	.fg(Color::Yellow)
48	+	.add_modifier(Modifier::BOLD),
49	+	)
50	+	.highlight_symbol("▶ ");
51	+
52	+	if matches!(app.focus, Focus::Search) {
53	+	let search_split =
54	+	Layout::vertical([Constraint::Min(1), Constraint::Length(3)]).split(chunks[0]);
55	+
56	+	let search_items: Vec<ListItem> = if let Some(indices) = &app.filtered_indices {
57	+	indices
58	+	.iter()
59	+	.filter_map(\|&i\| app.notes.get(i))
60	+	.map(\|n\| ListItem::new(n.title.as_str()))
61	+	.collect()
62	+	} else {
63	+	app.notes
64	+	.iter()
65	+	.map(\|n\| ListItem::new(n.title.as_str()))
66	+	.collect()
67	+	};
68	+	let search_list = List::new(search_items)
69	+	.block(
70	+	Block::default()
71	+	.title(" Notes ")
72	+	.borders(Borders::ALL)
73	+	.border_style(list_border_style),
74	+	)
75	+	.highlight_style(
76	+	Style::default()
77	+	.fg(Color::Yellow)
78	+	.add_modifier(Modifier::BOLD),
79	+	)
80	+	.highlight_symbol("▶ ");
81	+	frame.render_stateful_widget(search_list, search_split[0], &mut app.list_state);
82	+
83	+	let search_input = Paragraph::new(app.search_query.as_str()).block(
84	+	Block::default()
85	+	.title(" Search ")
86	+	.borders(Borders::ALL)
87	+	.border_style(Style::default().fg(Color::Yellow)),
88	+	);
89	+	frame.render_widget(search_input, search_split[1]);
90	+
91	+	let x = search_split[1].x + 1 + app.search_query.len() as u16;
92	+	let y = search_split[1].y + 1;
93	+	frame.set_cursor_position((x, y));
94	+	} else {
95	+	frame.render_stateful_widget(list, chunks[0], &mut app.list_state);
96	+	}
97	+
98	+	match app.focus {
99	+	Focus::CreateTitle \| Focus::CreateContent \| Focus::EditTitle \| Focus::EditContent => {
100	+	let form_title = match app.focus {
101	+	Focus::EditTitle \| Focus::EditContent => " Edit Note ",
102	+	_ => " New Note ",
103	+	};
104	+	let create_block = Block::default()
105	+	.title(form_title)
106	+	.borders(Borders::ALL)
107	+	.border_style(Style::default().fg(Color::Yellow));
108	+
109	+	let inner = create_block.inner(chunks[1]);
110	+	frame.render_widget(create_block, chunks[1]);
111	+
112	+	let form_layout =
113	+	Layout::vertical([Constraint::Length(3), Constraint::Min(1)]).split(inner);
114	+
115	+	let title_style = match app.focus {
116	+	Focus::CreateTitle \| Focus::EditTitle => Style::default().fg(Color::Yellow),
117	+	_ => Style::default().fg(Color::DarkGray),
118	+	};
119	+	let title_input = Paragraph::new(app.edit_title.as_str()).block(
120	+	Block::default()
121	+	.title(" Title ")
122	+	.borders(Borders::ALL)
123	+	.border_style(title_style),
124	+	);
125	+	frame.render_widget(title_input, form_layout[0]);
126	+
127	+	let content_style = match app.focus {
128	+	Focus::CreateContent \| Focus::EditContent => Style::default().fg(Color::Yellow),
129	+	_ => Style::default().fg(Color::DarkGray),
130	+	};
131	+	let mut content_input = Paragraph::new(app.edit_content.as_str()).block(
132	+	Block::default()
133	+	.title(" Content ")
134	+	.borders(Borders::ALL)
135	+	.border_style(content_style),
136	+	);
137	+	if app.wrap_content {
138	+	content_input = content_input.wrap(Wrap { trim: false });
139	+	}
140	+	content_input = content_input.scroll((app.edit_scroll, 0));
141	+	frame.render_widget(content_input, form_layout[1]);
142	+
143	+	let content_inner = Block::default().borders(Borders::ALL).inner(form_layout[1]);
144	+	let inner_width = content_inner.width;
145	+	let inner_height = content_inner.height;
146	+
147	+	match app.focus {
148	+	Focus::CreateTitle \| Focus::EditTitle => {
149	+	let x = form_layout[0].x + 1 + app.edit_title.len() as u16;
150	+	let y = form_layout[0].y + 1;
151	+	frame.set_cursor_position((x, y));
152	+	}
153	+	Focus::CreateContent \| Focus::EditContent => {
154	+	let (cx, cy) = if app.wrap_content {
155	+	app.cursor_position_wrapped(inner_width)
156	+	} else {
157	+	let last_line = app.edit_content.lines().last().unwrap_or("");
158	+	let line_count = app.edit_content.lines().count()
159	+	+ if app.edit_content.ends_with('\n') { 1 } else { 0 };
160	+	let y_offset = if line_count == 0 { 0 } else { line_count - 1 };
161	+	let col = if app.edit_content.ends_with('\n') {
162	+	0
163	+	} else {
164	+	last_line.len() as u16
165	+	};
166	+	(col, y_offset as u16)
167	+	};
168	+	app.auto_scroll_edit(cy, inner_height);
169	+	let screen_y = cy.saturating_sub(app.edit_scroll);
170	+	let x = content_inner.x + cx;
171	+	let y = content_inner.y + screen_y;
172	+	frame.set_cursor_position((x, y));
173	+	}
174	+	_ => {}
175	+	}
176	+	}
177	+	_ => {
178	+	let highlighted = match app.selected_note() {
179	+	Some(n) => app.highlighter.highlight_markdown(&n.content),
180	+	None => Text::raw(""),
181	+	};
182	+
183	+	let paragraph = Paragraph::new(highlighted)
184	+	.block(
185	+	Block::default()
186	+	.title(" Content ")
187	+	.borders(Borders::ALL)
188	+	.border_style(content_border_style),
189	+	)
190	+	.scroll((app.content_scroll, 0));
191	+
192	+	frame.render_widget(paragraph, chunks[1]);
193	+	}
194	+	}
195	+
196	+	let hints = match app.focus {
197	+	Focus::List => Line::from(vec![
198	+	Span::styled("j/k", Style::default().fg(Color::Yellow)),
199	+	Span::raw(": Navigate "),
200	+	Span::styled("Enter", Style::default().fg(Color::Yellow)),
201	+	Span::raw(": View "),
202	+	Span::styled("y", Style::default().fg(Color::Yellow)),
203	+	Span::raw(": Copy "),
204	+	Span::styled("e", Style::default().fg(Color::Yellow)),
205	+	Span::raw(": Edit "),
206	+	Span::styled("d", Style::default().fg(Color::Yellow)),
207	+	Span::raw(": Delete "),
208	+	Span::styled("c", Style::default().fg(Color::Yellow)),
209	+	Span::raw(": Create "),
210	+	Span::styled("/", Style::default().fg(Color::Yellow)),
211	+	Span::raw(": Search "),
212	+	Span::styled("?", Style::default().fg(Color::Yellow)),
213	+	Span::raw(": Help "),
214	+	Span::styled("q", Style::default().fg(Color::Yellow)),
215	+	Span::raw(": Quit"),
216	+	]),
217	+	Focus::Content => Line::from(vec![
218	+	Span::styled("j/k", Style::default().fg(Color::Yellow)),
219	+	Span::raw(": Scroll "),
220	+	Span::styled("y", Style::default().fg(Color::Yellow)),
221	+	Span::raw(": Copy "),
222	+	Span::styled("e", Style::default().fg(Color::Yellow)),
223	+	Span::raw(": Edit "),
224	+	Span::styled("Esc", Style::default().fg(Color::Yellow)),
225	+	Span::raw(": Back "),
226	+	Span::styled("?", Style::default().fg(Color::Yellow)),
227	+	Span::raw(": Help"),
228	+	]),
229	+	Focus::CreateTitle \| Focus::CreateContent \| Focus::EditTitle \| Focus::EditContent => {
230	+	Line::from(vec![
231	+	Span::styled("Tab", Style::default().fg(Color::Yellow)),
232	+	Span::raw(": Switch field "),
233	+	Span::styled("Ctrl+S", Style::default().fg(Color::Yellow)),
234	+	Span::raw(": Save "),
235	+	Span::styled("Ctrl+W", Style::default().fg(Color::Yellow)),
236	+	Span::raw(": Wrap "),
237	+	Span::styled("Esc", Style::default().fg(Color::Yellow)),
238	+	Span::raw(": Cancel"),
239	+	])
240	+	}
241	+	Focus::Search => Line::from(vec![
242	+	Span::styled("Type", Style::default().fg(Color::Yellow)),
243	+	Span::raw(": Filter "),
244	+	Span::styled("Enter", Style::default().fg(Color::Yellow)),
245	+	Span::raw(": Select "),
246	+	Span::styled("Esc", Style::default().fg(Color::Yellow)),
247	+	Span::raw(": Cancel"),
248	+	]),
249	+	};
250	+	frame.render_widget(Paragraph::new(hints), outer[1]);
251	+
252	+	if let Some((msg, _)) = &app.status_message {
253	+	let area = frame.area();
254	+	let msg_width = (msg.len() as u16 + 4).max(20).min(area.width.saturating_sub(4));
255	+	let popup_area = ratatui::layout::Rect {
256	+	x: (area.width.saturating_sub(msg_width)) / 2,
257	+	y: (area.height.saturating_sub(3)) / 2,
258	+	width: msg_width,
259	+	height: 3,
260	+	};
261	+	Clear.render(popup_area, frame.buffer_mut());
262	+	let status_popup = Paragraph::new(Line::from(msg.as_str()))
263	+	.style(Style::default().fg(Color::Green).add_modifier(Modifier::BOLD))
264	+	.alignment(Alignment::Center)
265	+	.block(
266	+	Block::default()
267	+	.borders(Borders::ALL)
268	+	.border_style(Style::default().fg(Color::Green)),
269	+	);
270	+	frame.render_widget(status_popup, popup_area);
271	+	}
272	+
273	+	if app.confirm_delete {
274	+	let delete_msg = match app.selected_note() {
275	+	Some(n) => format!("Delete {}? (y/n)", n.title),
276	+	None => "Delete note? (y/n)".to_string(),
277	+	};
278	+	let area = frame.area();
279	+	let msg_width = (delete_msg.len() as u16 + 4).max(24).min(area.width.saturating_sub(4));
280	+	let popup_area = ratatui::layout::Rect {
281	+	x: (area.width.saturating_sub(msg_width)) / 2,
282	+	y: (area.height.saturating_sub(3)) / 2,
283	+	width: msg_width,
284	+	height: 3,
285	+	};
286	+	Clear.render(popup_area, frame.buffer_mut());
287	+	let confirm_popup = Paragraph::new(Line::from(delete_msg))
288	+	.style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))
289	+	.alignment(Alignment::Center)
290	+	.block(
291	+	Block::default()
292	+	.borders(Borders::ALL)
293	+	.border_style(Style::default().fg(Color::Red)),
294	+	);
295	+	frame.render_widget(confirm_popup, popup_area);
296	+	}
297	+
298	+	if app.show_help {
299	+	let area = frame.area();
300	+	let popup_width = 34u16.min(area.width.saturating_sub(4));
301	+	let popup_height = 21u16.min(area.height.saturating_sub(4));
302	+	let popup_area = ratatui::layout::Rect {
303	+	x: (area.width.saturating_sub(popup_width)) / 2,
304	+	y: (area.height.saturating_sub(popup_height)) / 2,
305	+	width: popup_width,
306	+	height: popup_height,
307	+	};
308	+
309	+	let mut help_lines = vec![
310	+	Line::from(""),
311	+	Line::from(vec![
312	+	Span::styled(" j/↓ ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
313	+	Span::raw("Move down / Scroll down"),
314	+	]),
315	+	Line::from(vec![
316	+	Span::styled(" k/↑ ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
317	+	Span::raw("Move up / Scroll up"),
318	+	]),
319	+	Line::from(vec![
320	+	Span::styled(" Enter", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
321	+	Span::raw(" Focus content pane"),
322	+	]),
323	+	Line::from(vec![
324	+	Span::styled(" Esc ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
325	+	Span::raw("Back / Quit"),
326	+	]),
327	+	Line::from(vec![
328	+	Span::styled(" y ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
329	+	Span::raw("Copy note"),
330	+	]),
331	+	Line::from(vec![
332	+	Span::styled(" Y ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
333	+	Span::raw("Copy link"),
334	+	]),
335	+	Line::from(vec![
336	+	Span::styled(" o ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
337	+	Span::raw("Open in browser"),
338	+	]),
339	+	Line::from(vec![
340	+	Span::styled(" d ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
341	+	Span::raw("Delete note"),
342	+	]),
343	+	Line::from(vec![
344	+	Span::styled(" c ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
345	+	Span::raw("Create note"),
346	+	]),
347	+	Line::from(vec![
348	+	Span::styled(" e ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
349	+	Span::raw("Edit note"),
350	+	]),
351	+	Line::from(vec![
352	+	Span::styled(" E ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
353	+	Span::raw("Edit in $EDITOR"),
354	+	]),
355	+	Line::from(vec![
356	+	Span::styled(" / ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
357	+	Span::raw("Search notes"),
358	+	]),
359	+	Line::from(vec![
360	+	Span::styled(" ^W ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
361	+	Span::raw("Toggle word wrap (edit)"),
362	+	]),
363	+	];
364	+
365	+	if app.is_remote {
366	+	help_lines.push(Line::from(vec![
367	+	Span::styled(" r ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
368	+	Span::raw("Refresh notes"),
369	+	]));
370	+	}
371	+
372	+	help_lines.extend([
373	+	Line::from(vec![
374	+	Span::styled(" q ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
375	+	Span::raw("Quit"),
376	+	]),
377	+	Line::from(vec![
378	+	Span::styled(" ? ", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
379	+	Span::raw("Toggle this help"),
380	+	]),
381	+	Line::from(""),
382	+	Line::from(Span::styled(
383	+	" Press any key to close",
384	+	Style::default().fg(Color::DarkGray),
385	+	)),
386	+	]);
387	+
388	+	let help_text = Text::from(help_lines);
389	+
390	+	Clear.render(popup_area, frame.buffer_mut());
391	+	let help = Paragraph::new(help_text).block(
392	+	Block::default()
393	+	.title(" Keybindings ")
394	+	.borders(Borders::ALL)
395	+	.border_style(Style::default().fg(Color::Yellow)),
396	+	);
397	+	frame.render_widget(help, popup_area);
398	+	}
399	+	}

1	1		use nanoid::nanoid;
2		-	use rusqlite::{Connection, params};
	2	+	use rusqlite::{Connection, OptionalExtension, Row, params};
3	3		use serde::{Deserialize, Serialize};
4	4		use std::fmt;
5	5		use std::sync::{Arc, Mutex};
6	6
7	7		pub type Db = Arc<Mutex<Connection>>;
8	8
	9	+	const NOTE_COLUMNS: &str = "id, short_id, title, content, created_at, updated_at";
	10	+
	11	+	const SCHEMA: &str = "
	12	+	CREATE TABLE IF NOT EXISTS notes (
	13	+	id INTEGER PRIMARY KEY AUTOINCREMENT,
	14	+	short_id TEXT NOT NULL UNIQUE,
	15	+	title TEXT NOT NULL,
	16	+	content TEXT NOT NULL,
	17	+	created_at TEXT NOT NULL DEFAULT (datetime('now')),
	18	+	updated_at TEXT NOT NULL DEFAULT (datetime('now'))
	19	+	);
	20	+
	21	+	CREATE TABLE IF NOT EXISTS sessions (
	22	+	id INTEGER PRIMARY KEY AUTOINCREMENT,
	23	+	token TEXT NOT NULL UNIQUE,
	24	+	expires_at TEXT NOT NULL
	25	+	);
	26	+	";
	27	+
9	28		#[derive(Debug)]
10	29		pub enum DbError {
11	30		Sqlite(rusqlite::Error),

39	58		pub updated_at: String,
40	59		}
41	60
	61	+	impl Note {
	62	+	fn from_row(row: &Row) -> rusqlite::Result<Self> {
	63	+	Ok(Note {
	64	+	id: row.get(0)?,
	65	+	short_id: row.get(1)?,
	66	+	title: row.get(2)?,
	67	+	content: row.get(3)?,
	68	+	created_at: row.get(4)?,
	69	+	updated_at: row.get(5)?,
	70	+	})
	71	+	}
	72	+	}
	73	+
	74	+	/// Incoming note payload from JSON/form requests. Shared by server and backend.
	75	+	#[derive(Debug, Serialize, Deserialize)]
	76	+	pub struct NoteInput {
	77	+	pub title: String,
	78	+	pub content: String,
	79	+	}
	80	+
42	81		pub fn init_db() -> Db {
43	82		let path = std::env::var("JOTTS_DB_PATH").unwrap_or_else(\|_\| "jotts.sqlite".to_string());
44	83		let conn = Connection::open(&path).expect("Failed to open database");
45		-
46		-	conn.execute_batch(
47		-	"CREATE TABLE IF NOT EXISTS notes (
48		-	id INTEGER PRIMARY KEY AUTOINCREMENT,
49		-	short_id TEXT NOT NULL UNIQUE,
50		-	title TEXT NOT NULL,
51		-	content TEXT NOT NULL,
52		-	created_at TEXT NOT NULL DEFAULT (datetime('now')),
53		-	updated_at TEXT NOT NULL DEFAULT (datetime('now'))
54		-	);
55		-
56		-	CREATE TABLE IF NOT EXISTS sessions (
57		-	id INTEGER PRIMARY KEY AUTOINCREMENT,
58		-	token TEXT NOT NULL UNIQUE,
59		-	expires_at TEXT NOT NULL
60		-	);"
61		-	)
62		-	.expect("Failed to create tables");
63		-
	84	+	conn.execute_batch(SCHEMA).expect("Failed to create tables");
64	85		Arc::new(Mutex::new(conn))
65	86		}
66	87

73	94		)?;
74	95		let id = conn.last_insert_rowid();
75	96		let note = conn.query_row(
76		-	"SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE id = ?1",
	97	+	&format!("SELECT {NOTE_COLUMNS} FROM notes WHERE id = ?1"),
77	98		params![id],
78		-	\|row\| {
79		-	Ok(Note {
80		-	id: row.get(0)?,
81		-	short_id: row.get(1)?,
82		-	title: row.get(2)?,
83		-	content: row.get(3)?,
84		-	created_at: row.get(4)?,
85		-	updated_at: row.get(5)?,
86		-	})
87		-	},
	99	+	Note::from_row,
88	100		)?;
89	101		Ok(note)
90	102		}
91	103
92	104		pub fn get_note_by_short_id(db: &Db, short_id: &str) -> Result<Option<Note>, DbError> {
93	105		let conn = db.lock().map_err(\|_\| DbError::LockPoisoned)?;
94		-	match conn.query_row(
95		-	"SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE short_id = ?1",
96		-	params![short_id],
97		-	\|row\| {
98		-	Ok(Note {
99		-	id: row.get(0)?,
100		-	short_id: row.get(1)?,
101		-	title: row.get(2)?,
102		-	content: row.get(3)?,
103		-	created_at: row.get(4)?,
104		-	updated_at: row.get(5)?,
105		-	})
106		-	},
107		-	) {
108		-	Ok(note) => Ok(Some(note)),
109		-	Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
110		-	Err(e) => Err(DbError::Sqlite(e)),
111		-	}
	106	+	let note = conn
	107	+	.query_row(
	108	+	&format!("SELECT {NOTE_COLUMNS} FROM notes WHERE short_id = ?1"),
	109	+	params![short_id],
	110	+	Note::from_row,
	111	+	)
	112	+	.optional()?;
	113	+	Ok(note)
112	114		}
113	115
114	116		pub fn get_all_notes(db: &Db) -> Result<Vec<Note>, DbError> {
115	117		let conn = db.lock().map_err(\|_\| DbError::LockPoisoned)?;
116		-	let mut stmt = conn.prepare(
117		-	"SELECT id, short_id, title, content, created_at, updated_at FROM notes ORDER BY id DESC",
118		-	)?;
	118	+	let mut stmt =
	119	+	conn.prepare(&format!("SELECT {NOTE_COLUMNS} FROM notes ORDER BY id DESC"))?;
119	120		let notes = stmt
120		-	.query_map([], \|row\| {
121		-	Ok(Note {
122		-	id: row.get(0)?,
123		-	short_id: row.get(1)?,
124		-	title: row.get(2)?,
125		-	content: row.get(3)?,
126		-	created_at: row.get(4)?,
127		-	updated_at: row.get(5)?,
128		-	})
129		-	})?
	121	+	.query_map([], Note::from_row)?
130	122		.collect::<Result<Vec<_>, _>>()?;
131	123		Ok(notes)
132	124		}

145	137		if rows == 0 {
146	138		return Ok(None);
147	139		}
148		-	match conn.query_row(
149		-	"SELECT id, short_id, title, content, created_at, updated_at FROM notes WHERE short_id = ?1",
150		-	params![short_id],
151		-	\|row\| {
152		-	Ok(Note {
153		-	id: row.get(0)?,
154		-	short_id: row.get(1)?,
155		-	title: row.get(2)?,
156		-	content: row.get(3)?,
157		-	created_at: row.get(4)?,
158		-	updated_at: row.get(5)?,
159		-	})
160		-	},
161		-	) {
162		-	Ok(note) => Ok(Some(note)),
163		-	Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
164		-	Err(e) => Err(DbError::Sqlite(e)),
165		-	}
	140	+	let note = conn
	141	+	.query_row(
	142	+	&format!("SELECT {NOTE_COLUMNS} FROM notes WHERE short_id = ?1"),
	143	+	params![short_id],
	144	+	Note::from_row,
	145	+	)
	146	+	.optional()?;
	147	+	Ok(note)
166	148		}
167	149
168	150		pub fn delete_note_by_short_id(db: &Db, short_id: &str) -> Result<bool, DbError> {

219	201
220	202		fn test_db() -> Db {
221	203		let conn = Connection::open_in_memory().unwrap();
222		-	conn.execute_batch(
223		-	"CREATE TABLE IF NOT EXISTS notes (
224		-	id INTEGER PRIMARY KEY AUTOINCREMENT,
225		-	short_id TEXT NOT NULL UNIQUE,
226		-	title TEXT NOT NULL,
227		-	content TEXT NOT NULL,
228		-	created_at TEXT NOT NULL DEFAULT (datetime('now')),
229		-	updated_at TEXT NOT NULL DEFAULT (datetime('now'))
230		-	);
231		-	CREATE TABLE IF NOT EXISTS sessions (
232		-	id INTEGER PRIMARY KEY AUTOINCREMENT,
233		-	token TEXT NOT NULL UNIQUE,
234		-	expires_at TEXT NOT NULL
235		-	);",
236		-	)
237		-	.unwrap();
	204	+	conn.execute_batch(SCHEMA).unwrap();
238	205		Arc::new(Mutex::new(conn))
239	206		}
240	207

12	12		use std::sync::Arc;
13	13
14	14		use crate::auth;
15		-	use crate::db::{self, Db, Note};
	15	+	use crate::db::{self, Db, DbError, Note, NoteInput};
	16	+
	17	+	impl IntoResponse for DbError {
	18	+	fn into_response(self) -> Response {
	19	+	tracing::error!("{}", self);
	20	+	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
	21	+	}
	22	+	}
	23	+
	24	+	fn redirect_with_cookie(target: &str, cookie: String) -> Response {
	25	+	let mut resp = Redirect::to(target).into_response();
	26	+	resp.headers_mut().insert(
	27	+	axum::http::header::SET_COOKIE,
	28	+	HeaderValue::from_str(&cookie).unwrap(),
	29	+	);
	30	+	resp
	31	+	}
16	32
17	33		#[derive(Clone)]
18	34		pub struct AppState {

76	92		password: String,
77	93		}
78	94
79		-	#[derive(serde::Deserialize)]
80		-	struct NoteForm {
81		-	title: String,
82		-	content: String,
83		-	}
84		-
85		-	#[derive(serde::Deserialize)]
86		-	struct NoteJson {
87		-	title: String,
88		-	content: String,
89		-	}
90		-
91	95		// --- API key middleware ---
92	96
93	97		async fn api_key_guard(

117	121
118	122		// --- JSON API handlers ---
119	123
120		-	async fn api_list_notes(State(state): State<Arc<AppState>>) -> Response {
121		-	match db::get_all_notes(&state.db) {
122		-	Ok(notes) => Json(notes).into_response(),
123		-	Err(e) => {
124		-	tracing::error!("Failed to list notes: {}", e);
125		-	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
126		-	}
127		-	}
	124	+	async fn api_list_notes(State(state): State<Arc<AppState>>) -> Result<Response, DbError> {
	125	+	Ok(Json(db::get_all_notes(&state.db)?).into_response())
128	126		}
129	127
130	128		async fn api_get_note(
131	129		State(state): State<Arc<AppState>>,
132	130		Path(short_id): Path<String>,
133		-	) -> Response {
134		-	match db::get_note_by_short_id(&state.db, &short_id) {
135		-	Ok(Some(note)) => Json(note).into_response(),
136		-	Ok(None) => StatusCode::NOT_FOUND.into_response(),
137		-	Err(e) => {
138		-	tracing::error!("Failed to get note: {}", e);
139		-	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
140		-	}
141		-	}
	131	+	) -> Result<Response, DbError> {
	132	+	Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
	133	+	Some(note) => Json(note).into_response(),
	134	+	None => StatusCode::NOT_FOUND.into_response(),
	135	+	})
142	136		}
143	137
144	138		async fn api_create_note(
145	139		State(state): State<Arc<AppState>>,
146		-	Json(body): Json<NoteJson>,
147		-	) -> Response {
	140	+	Json(body): Json<NoteInput>,
	141	+	) -> Result<Response, DbError> {
148	142		let title = body.title.trim();
149	143		if title.is_empty() {
150		-	return (StatusCode::BAD_REQUEST, "title required").into_response();
151		-	}
152		-	match db::create_note(&state.db, title, &body.content) {
153		-	Ok(note) => (StatusCode::CREATED, Json(note)).into_response(),
154		-	Err(e) => {
155		-	tracing::error!("Failed to create note: {}", e);
156		-	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
157		-	}
	144	+	return Ok((StatusCode::BAD_REQUEST, "title required").into_response());
158	145		}
	146	+	let note = db::create_note(&state.db, title, &body.content)?;
	147	+	Ok((StatusCode::CREATED, Json(note)).into_response())
159	148		}
160	149
161	150		async fn api_update_note(
162	151		State(state): State<Arc<AppState>>,
163	152		Path(short_id): Path<String>,
164		-	Json(body): Json<NoteJson>,
165		-	) -> Response {
	153	+	Json(body): Json<NoteInput>,
	154	+	) -> Result<Response, DbError> {
166	155		let title = body.title.trim();
167	156		if title.is_empty() {
168		-	return (StatusCode::BAD_REQUEST, "title required").into_response();
169		-	}
170		-	match db::update_note_by_short_id(&state.db, &short_id, title, &body.content) {
171		-	Ok(Some(note)) => Json(note).into_response(),
172		-	Ok(None) => StatusCode::NOT_FOUND.into_response(),
173		-	Err(e) => {
174		-	tracing::error!("Failed to update note: {}", e);
175		-	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
176		-	}
	157	+	return Ok((StatusCode::BAD_REQUEST, "title required").into_response());
177	158		}
	159	+	Ok(
	160	+	match db::update_note_by_short_id(&state.db, &short_id, title, &body.content)? {
	161	+	Some(note) => Json(note).into_response(),
	162	+	None => StatusCode::NOT_FOUND.into_response(),
	163	+	},
	164	+	)
178	165		}
179	166
180	167		async fn api_delete_note(
181	168		State(state): State<Arc<AppState>>,
182	169		Path(short_id): Path<String>,
183		-	) -> Response {
184		-	match db::delete_note_by_short_id(&state.db, &short_id) {
185		-	Ok(true) => StatusCode::NO_CONTENT.into_response(),
186		-	Ok(false) => StatusCode::NOT_FOUND.into_response(),
187		-	Err(e) => {
188		-	tracing::error!("Failed to delete note: {}", e);
189		-	(StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()
190		-	}
191		-	}
	170	+	) -> Result<Response, DbError> {
	171	+	Ok(match db::delete_note_by_short_id(&state.db, &short_id)? {
	172	+	true => StatusCode::NO_CONTENT.into_response(),
	173	+	false => StatusCode::NOT_FOUND.into_response(),
	174	+	})
192	175		}
193	176
194	177		// --- Static file handlers ---

249	232		return Redirect::to("/login?error=Server+error").into_response();
250	233		}
251	234
252		-	let cookie = auth::build_session_cookie(&token, state.cookie_secure);
253		-	let mut resp = Redirect::to("/").into_response();
254		-	resp.headers_mut().insert(
255		-	axum::http::header::SET_COOKIE,
256		-	HeaderValue::from_str(&cookie).unwrap(),
257		-	);
258		-	resp
	235	+	redirect_with_cookie("/", auth::build_session_cookie(&token, state.cookie_secure))
259	236		}
260	237
261	238		async fn get_logout(State(state): State<Arc<AppState>>, headers: axum::http::HeaderMap) -> Response {

271	248		}
272	249		}
273	250
274		-	let cookie = auth::clear_session_cookie();
275		-	let mut resp = Redirect::to("/login").into_response();
276		-	resp.headers_mut().insert(
277		-	axum::http::header::SET_COOKIE,
278		-	HeaderValue::from_str(&cookie).unwrap(),
279		-	);
280		-	resp
	251	+	redirect_with_cookie("/login", auth::clear_session_cookie())
281	252		}
282	253
283	254		// --- Note handlers ---

285	256		async fn get_index(
286	257		_session: auth::AuthSession,
287	258		State(state): State<Arc<AppState>>,
288		-	) -> Response {
289		-	match db::get_all_notes(&state.db) {
290		-	Ok(notes) => WebTemplate(IndexTemplate { notes }).into_response(),
291		-	Err(e) => {
292		-	tracing::error!("Failed to list notes: {}", e);
293		-	(StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
294		-	}
295		-	}
	259	+	) -> Result<Response, DbError> {
	260	+	let notes = db::get_all_notes(&state.db)?;
	261	+	Ok(WebTemplate(IndexTemplate { notes }).into_response())
296	262		}
297	263
298	264		async fn get_new_note(

305	271		async fn post_create_note(
306	272		_session: auth::AuthSession,
307	273		State(state): State<Arc<AppState>>,
308		-	Form(form): Form<NoteForm>,
	274	+	Form(form): Form<NoteInput>,
309	275		) -> Response {
310	276		let title = form.title.trim();
311	277		if title.is_empty() {

336	302		_session: auth::AuthSession,
337	303		State(state): State<Arc<AppState>>,
338	304		Path(short_id): Path<String>,
339		-	) -> Response {
340		-	match db::get_note_by_short_id(&state.db, &short_id) {
341		-	Ok(Some(note)) => {
	305	+	) -> Result<Response, DbError> {
	306	+	Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
	307	+	Some(note) => {
342	308		let rendered_content = render_markdown(&note.content);
343	309		WebTemplate(ViewTemplate {
344	310		note,

346	312		})
347	313		.into_response()
348	314		}
349		-	Ok(None) => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
350		-	Err(e) => {
351		-	tracing::error!("Failed to get note: {}", e);
352		-	(StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
353		-	}
354		-	}
	315	+	None => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
	316	+	})
355	317		}
356	318
357	319		async fn get_edit_note(

359	321		State(state): State<Arc<AppState>>,
360	322		Path(short_id): Path<String>,
361	323		Query(q): Query<FlashQuery>,
362		-	) -> Response {
363		-	match db::get_note_by_short_id(&state.db, &short_id) {
364		-	Ok(Some(note)) => WebTemplate(EditTemplate {
	324	+	) -> Result<Response, DbError> {
	325	+	Ok(match db::get_note_by_short_id(&state.db, &short_id)? {
	326	+	Some(note) => WebTemplate(EditTemplate {
365	327		note,
366	328		error: q.error,
367	329		})
368	330		.into_response(),
369		-	Ok(None) => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
370		-	Err(e) => {
371		-	tracing::error!("Failed to get note: {}", e);
372		-	(StatusCode::INTERNAL_SERVER_ERROR, Html("Server error".to_string())).into_response()
373		-	}
374		-	}
	331	+	None => (StatusCode::NOT_FOUND, Html("Note not found".to_string())).into_response(),
	332	+	})
375	333		}
376	334
377	335		async fn post_update_note(
378	336		_session: auth::AuthSession,
379	337		State(state): State<Arc<AppState>>,
380	338		Path(short_id): Path<String>,
381		-	Form(form): Form<NoteForm>,
	339	+	Form(form): Form<NoteInput>,
382	340		) -> Response {
383	341		let title = form.title.trim();
384	342		if title.is_empty() {