const std = @import("std");
const debug_trace = @import("../shared/debug_trace.zig");
const io_mod = @import("../shared/io.zig");
const session = @import("session.zig");

const Allocator = std.mem.Allocator;

pub const sidecar_file = "display.json";
pub const max_sidecar_bytes: usize = 16 * 1024;
const max_title_words: usize = 8;
pub const max_title_bytes: usize = 240;
const max_preview_lines: usize = 2;
const max_preview_bytes: usize = 240;
pub const fallback_title = "Untitled session";
pub const image_title = "Image session";

pub const DisplayMetadata = struct {
    present: bool = false,
    title: []u8,
    preview: ?[]u8 = null,
    origin_workspace_root: ?[]u8 = null,

    pub fn deinit(self: *DisplayMetadata, alloc: Allocator) void {
        alloc.free(self.title);
        if (self.preview) |preview| alloc.free(preview);
        if (self.origin_workspace_root) |root| alloc.free(root);
        self.* = undefined;
    }
};

pub fn missingFallback(alloc: Allocator) !DisplayMetadata {
    return .{
        .present = false,
        .title = try alloc.dupe(u8, fallback_title),
    };
}

pub fn deriveFromHistory(alloc: Allocator, history: []const session.HistoryTurn) !DisplayMetadata {
    const candidate = firstPromptCandidate(history) orelse {
        return if (history.len == 0) missingFallback(alloc) else missingFallbackPresent(alloc);
    };
    switch (candidate) {
        .text => |prompt| {
            if (!std.unicode.utf8ValidateSlice(prompt)) return missingFallbackPresent(alloc);

            const first_line = firstNonEmptyLine(prompt) orelse return missingFallbackPresent(alloc);
            const title = try cappedTitle(alloc, first_line);
            errdefer alloc.free(title);
            const preview = try boundedPreview(alloc, prompt);
            errdefer if (preview) |value| alloc.free(value);

            return .{
                .present = true,
                .title = title,
                .preview = preview,
            };
        },
        .image_only => return .{
            .present = true,
            .title = try alloc.dupe(u8, image_title),
        },
    }
}

fn missingFallbackPresent(alloc: Allocator) !DisplayMetadata {
    return .{
        .present = true,
        .title = try alloc.dupe(u8, fallback_title),
    };
}

const PromptCandidate = union(enum) {
    text: []const u8,
    image_only,
};

fn firstPromptCandidate(history: []const session.HistoryTurn) ?PromptCandidate {
    for (history) |turn| {
        switch (turn) {
            .assistant => |entry| if (promptCandidateFromUser(entry.user)) |candidate| return candidate,
            .background_command => |entry| if (promptCandidateFromUser(entry.user)) |candidate| return candidate,
            .interrupted => |entry| if (promptCandidateFromUser(entry.user)) |candidate| return candidate,
            .compacted_summary => {},
        }
    }
    return null;
}

fn promptCandidateFromUser(user: session.UserTurn) ?PromptCandidate {
    const trimmed = std.mem.trim(u8, user.text, " \t\r\n");
    if (trimmed.len > 0 and !isSlashCommandOnly(trimmed)) return .{ .text = user.text };
    if (user.images.len > 0) return .image_only;
    return null;
}

fn isSlashCommandOnly(trimmed: []const u8) bool {
    return trimmed.len > 0 and trimmed[0] == '/' and std.mem.findScalar(u8, trimmed, '\n') == null;
}

fn firstNonEmptyLine(text: []const u8) ?[]const u8 {
    var it = std.mem.splitScalar(u8, text, '\n');
    while (it.next()) |line| {
        const trimmed = std.mem.trim(u8, line, " \t\r");
        if (trimmed.len > 0) return trimmed;
    }
    return null;
}

fn cappedTitle(alloc: Allocator, line: []const u8) ![]u8 {
    var out: std.ArrayList(u8) = .empty;
    errdefer out.deinit(alloc);

    var words: usize = 0;
    var index: usize = 0;
    while (index < line.len and words < max_title_words) {
        while (index < line.len and std.ascii.isWhitespace(line[index])) index += 1;
        const start = index;
        while (index < line.len and !std.ascii.isWhitespace(line[index])) index += 1;
        if (index == start) break;
        const separator: usize = if (words > 0) 1 else 0;
        const remaining = max_title_bytes - @min(max_title_bytes, out.items.len + separator);
        const take = validUtf8PrefixLen(line[start..index], remaining);
        if (take == 0) break;
        if (words > 0) try out.append(alloc, ' ');
        try out.appendSlice(alloc, line[start .. start + take]);
        words += 1;
    }

    if (out.items.len == 0) return try alloc.dupe(u8, fallback_title);
    return try out.toOwnedSlice(alloc);
}

fn boundedPreview(alloc: Allocator, text: []const u8) !?[]u8 {
    var out: std.ArrayList(u8) = .empty;
    errdefer out.deinit(alloc);

    var line_count: usize = 0;
    var it = std.mem.splitScalar(u8, text, '\n');
    while (it.next()) |line| {
        if (line_count == max_preview_lines) break;
        const trimmed = std.mem.trim(u8, line, " \t\r");
        if (trimmed.len == 0) continue;
        if (out.items.len > 0) try out.append(alloc, '\n');
        const remaining = max_preview_bytes - @min(max_preview_bytes, out.items.len);
        if (remaining == 0) break;
        const take = validUtf8PrefixLen(trimmed, remaining);
        try out.appendSlice(alloc, trimmed[0..take]);
        line_count += 1;
        if (take < trimmed.len or out.items.len >= max_preview_bytes) break;
    }

    if (out.items.len == 0) {
        out.deinit(alloc);
        return null;
    }
    return try out.toOwnedSlice(alloc);
}

fn validUtf8PrefixLen(text: []const u8, max_bytes: usize) usize {
    var end = @min(text.len, max_bytes);
    while (end > 0 and !std.unicode.utf8ValidateSlice(text[0..end])) {
        end -= 1;
    }
    return end;
}

pub fn encodeSidecar(alloc: Allocator, metadata: DisplayMetadata) ![]u8 {
    var out: std.Io.Writer.Allocating = .init(alloc);
    defer out.deinit();

    try out.writer.writeAll("{\"schema_version\":1,\"title\":");
    try std.json.Stringify.value(metadata.title, .{}, &out.writer);
    try out.writer.writeAll(",\"preview\":");
    if (metadata.preview) |preview| {
        try std.json.Stringify.value(preview, .{}, &out.writer);
    } else {
        try out.writer.writeAll("null");
    }
    try out.writer.writeAll(",\"origin_workspace_root\":");
    if (metadata.origin_workspace_root) |root| {
        try std.json.Stringify.value(root, .{}, &out.writer);
    } else {
        try out.writer.writeAll("null");
    }
    try out.writer.writeByte('}');

    if (out.written().len > max_sidecar_bytes) return error.DisplayMetadataTooLarge;
    return try out.toOwnedSlice();
}

pub fn decodeSidecar(alloc: Allocator, bytes: []const u8) !DisplayMetadata {
    if (bytes.len == 0 or bytes.len > max_sidecar_bytes) return error.InvalidDisplayMetadata;
    var parsed = std.json.parseFromSlice(std.json.Value, alloc, bytes, .{}) catch |err| switch (err) {
        error.OutOfMemory => return error.OutOfMemory,
        else => return error.InvalidDisplayMetadata,
    };
    defer parsed.deinit();
    if (parsed.value != .object) return error.InvalidDisplayMetadata;
    const root = parsed.value.object;
    const schema = root.get("schema_version") orelse return error.InvalidDisplayMetadata;
    if (schema != .integer or schema.integer != 1) return error.InvalidDisplayMetadata;

    const title = try requiredStringDup(alloc, root.get("title"));
    errdefer alloc.free(title);
    if (title.len == 0 or !std.unicode.utf8ValidateSlice(title)) {
        return error.InvalidDisplayMetadata;
    }
    const preview = try optionalStringDup(alloc, root.get("preview"));
    errdefer if (preview) |value| alloc.free(value);
    const origin = try optionalStringDup(alloc, root.get("origin_workspace_root"));
    errdefer if (origin) |value| alloc.free(value);

    return .{
        .present = true,
        .title = title,
        .preview = preview,
        .origin_workspace_root = origin,
    };
}

pub fn decodeSidecarOrFallback(alloc: Allocator, bytes: []const u8) !DisplayMetadata {
    return decodeSidecar(alloc, bytes) catch |err| switch (err) {
        error.OutOfMemory => return error.OutOfMemory,
        else => {
            debug_trace.logf("session", "event=display_sidecar_invalid err={s}", .{@errorName(err)});
            return missingFallback(alloc);
        },
    };
}

pub fn readSidecarOrFallback(
    alloc: Allocator,
    session_dir: *io_mod.VerifiedDir,
) !DisplayMetadata {
    var file = session_dir.dir.openFile(io_mod.getIo(), sidecar_file, .{
        .mode = .read_only,
        .allow_directory = false,
        .follow_symlinks = false,
        .resolve_beneath = true,
    }) catch |err| switch (err) {
        error.FileNotFound => return missingFallback(alloc),
        error.NotDir, error.SymLinkLoop, error.IsDir => return missingFallback(alloc),
        else => return err,
    };
    defer file.close(io_mod.getIo());
    const bytes = io_mod.readFileToEnd(alloc, &file, max_sidecar_bytes) catch |err| switch (err) {
        error.OutOfMemory => return error.OutOfMemory,
        else => {
            debug_trace.logf("session", "event=display_sidecar_unreadable err={s}", .{@errorName(err)});
            return missingFallback(alloc);
        },
    };
    defer alloc.free(bytes);
    return decodeSidecarOrFallback(alloc, bytes);
}

pub fn writeSidecar(
    alloc: Allocator,
    session_dir: *io_mod.VerifiedDir,
    metadata: DisplayMetadata,
) !void {
    const bytes = try encodeSidecar(alloc, metadata);
    defer alloc.free(bytes);
    try io_mod.durableReplaceVerified(alloc, session_dir, sidecar_file, bytes);
}

fn requiredStringDup(alloc: Allocator, maybe_value: ?std.json.Value) ![]u8 {
    const value = maybe_value orelse return error.InvalidDisplayMetadata;
    if (value != .string) return error.InvalidDisplayMetadata;
    return try alloc.dupe(u8, value.string);
}

fn optionalStringDup(alloc: Allocator, maybe_value: ?std.json.Value) !?[]u8 {
    const value = maybe_value orelse return error.InvalidDisplayMetadata;
    switch (value) {
        .null => return null,
        .string => |text| {
            if (!std.unicode.utf8ValidateSlice(text)) return error.InvalidDisplayMetadata;
            return try alloc.dupe(u8, text);
        },
        else => return error.InvalidDisplayMetadata,
    }
}

test "display metadata derives capped title from first prompt line and bounded preview" {
    const alloc = std.testing.allocator;
    const history = [_]session.HistoryTurn{
        makeAssistantTurn(
            "one two three four five six seven eight nine ten\nsecond line kept\nthird line dropped",
        ),
    };

    var metadata = try deriveFromHistory(alloc, &history);
    defer metadata.deinit(alloc);

    try std.testing.expect(metadata.present);
    try std.testing.expectEqualStrings("one two three four five six seven eight", metadata.title);
    try std.testing.expectEqualStrings(
        "one two three four five six seven eight nine ten\nsecond line kept",
        metadata.preview.?,
    );
}

test "display metadata byte-caps a single-token title" {
    const alloc = std.testing.allocator;
    const long_token = "x" ** 512;
    const history = [_]session.HistoryTurn{makeAssistantTurn(long_token)};

    var metadata = try deriveFromHistory(alloc, &history);
    defer metadata.deinit(alloc);

    try std.testing.expect(metadata.present);
    try std.testing.expectEqual(max_title_bytes, metadata.title.len);
}

test "display metadata falls back for empty or non-text initial history" {
    const alloc = std.testing.allocator;
    var no_history = try deriveFromHistory(alloc, &.{});
    defer no_history.deinit(alloc);
    try std.testing.expect(!no_history.present);
    try std.testing.expectEqualStrings("Untitled session", no_history.title);

    const empty_history = [_]session.HistoryTurn{
        makeAssistantTurn("   \n\t"),
    };

    var metadata = try deriveFromHistory(alloc, &empty_history);
    defer metadata.deinit(alloc);

    try std.testing.expect(metadata.present);
    try std.testing.expectEqualStrings("Untitled session", metadata.title);
    try std.testing.expect(metadata.preview == null);
}

test "display metadata skips slash-only turns and handles image-only sessions" {
    const alloc = std.testing.allocator;
    const slash_then_prompt = [_]session.HistoryTurn{
        makeAssistantTurn("/resume"),
        makeAssistantTurn("real prompt title"),
    };

    var metadata = try deriveFromHistory(alloc, &slash_then_prompt);
    defer metadata.deinit(alloc);
    try std.testing.expect(metadata.present);
    try std.testing.expectEqualStrings("real prompt title", metadata.title);

    const image = session.ImageAttachment{
        .path = @constCast("/tmp/image.png"),
        .media_type = @constCast("image/png"),
    };
    var images = [_]session.ImageAttachment{image};
    const image_only = [_]session.HistoryTurn{
        makeAssistantTurnWithImages("", images[0..]),
    };

    var image_metadata = try deriveFromHistory(alloc, &image_only);
    defer image_metadata.deinit(alloc);
    try std.testing.expect(image_metadata.present);
    try std.testing.expectEqualStrings("Image session", image_metadata.title);
    try std.testing.expect(image_metadata.preview == null);
}

test "display metadata sidecar round trips and invalid sidecar falls back" {
    const alloc = std.testing.allocator;
    const source = DisplayMetadata{
        .present = true,
        .title = @constCast("Plan release notes"),
        .preview = @constCast("Plan release notes\nship checklist"),
        .origin_workspace_root = @constCast("/tmp/origin"),
    };

    const bytes = try encodeSidecar(alloc, source);
    defer alloc.free(bytes);

    var decoded = try decodeSidecar(alloc, bytes);
    defer decoded.deinit(alloc);

    try std.testing.expect(decoded.present);
    try std.testing.expectEqualStrings("Plan release notes", decoded.title);
    try std.testing.expectEqualStrings("Plan release notes\nship checklist", decoded.preview.?);
    try std.testing.expectEqualStrings("/tmp/origin", decoded.origin_workspace_root.?);

    var fallback = try decodeSidecarOrFallback(alloc, "{\"schema_version\":1,\"title\":42}");
    defer fallback.deinit(alloc);
    try std.testing.expect(!fallback.present);
    try std.testing.expectEqualStrings("Untitled session", fallback.title);
    try std.testing.expect(fallback.preview == null);
}

fn makeAssistantTurn(text: []const u8) session.HistoryTurn {
    return makeAssistantTurnWithImages(text, &.{});
}

fn makeAssistantTurnWithImages(text: []const u8, images: []session.ImageAttachment) session.HistoryTurn {
    return .{ .assistant = .{
        .user = .{ .text = @constCast(text), .images = images },
        .assistant = @constCast("reply"),
        .execution = .{},
    } };
}