const std = @import("std");
const c = @cImport({
    @cInclude("time.h");
});

const log = std.log.scoped(.gen);
const Context = @import("main.zig").Context;

pub fn generate(ctx: *Context) !void {
    try genIndexHtml(ctx);

    log.info("Generated index.", .{});

    try genSite(ctx);

    log.info("Generated {d} files.", .{ctx.generated});
    log.info("Generated {d} tildes.", .{ctx.tilde});
}

fn genIndexHtml(ctx: *Context) !void {
    const srcpathIndex = try util.joinIn(ctx.allocator(), &.{Context.params.PAGE_PATH}, &.{"index.htm"});
    defer ctx.allocator().free(srcpathIndex);

    const f = try FileSwapper.createAt(ctx.allocator(), srcpathIndex);
    defer f.close();

    try f.writer().writeAll(
        \\<ul class="col2 captial">
        \\
    );

    // alphanum ascii sort
    std.mem.sort(
        []const u8,
        ctx.pages,
        {},
        struct {
            fn lessthan(_: void, a: []const u8, b: []const u8) bool {
                return std.ascii.lessThanIgnoreCase(a, b);
            }
        }.lessthan,
    );

    for (ctx.pages) |p| {
        if (std.mem.startsWith(u8, p, "meta.")) continue;

        const dstname = try util.stripExt(p);
        const dstpath = try util.joinIn(ctx.allocator(), &.{Context.params.SITE_PATH}, &.{ dstname, ".html" });
        defer ctx.allocator().free(dstpath);

        try f.writer().print(
            \\<li><a href="/{[LINK]s}">{[NAME]s}</a></li>
            \\
        , .{
            .LINK = dstpath,
            .NAME = dstname,
        });
    }

    try f.writer().writeAll(
        \\</ul>
        \\
    );
}

const FileSwapper = struct {
    allocator: std.mem.Allocator,
    target_path: []const u8,
    tmp_path: []const u8,
    tmp: std.fs.File,

    fn createAt(allocator: std.mem.Allocator, path: []const u8) !FileSwapper {
        const target_dir = std.fs.path.dirname(path) orelse ".";
        const target_name = std.fs.path.basename(path);

        const tmp_name = try std.fmt.allocPrint(allocator, ".{s}", .{target_name});
        defer allocator.free(tmp_name);

        const tmp_path = try std.fs.path.join(allocator, &.{ target_dir, tmp_name });

        const f = try std.fs.cwd().createFile(tmp_path, .{});

        return .{
            .allocator = allocator,
            .target_path = path,
            .tmp_path = tmp_path,
            .tmp = f,
        };
    }

    fn writer(self: FileSwapper) std.fs.File.Writer {
        return self.tmp.writer();
    }

    fn close(self: FileSwapper) void {
        defer self.allocator.free(self.tmp_path);
        defer self.tmp.close();

        self.tmp.sync() catch @panic("sync tmp file");

        std.debug.print("??? {s} => {s}\n", .{ self.tmp_path, self.target_path });
        std.fs.rename(std.fs.cwd(), self.tmp_path, std.fs.cwd(), self.target_path) catch @panic("rename tmp file");
    }
};

fn genSite(ctx: *Context) !void {
    for (ctx.pages) |p| {
        const pname = std.fs.path.basename(p);
        if (std.mem.startsWith(u8, pname, "meta.")) {
            try meta(ctx, p);
            continue;
        }

        const dstname = try util.stripExt(p);
        const srcpath = try util.joinIn(ctx.allocator(), &.{Context.params.PAGE_PATH}, &.{ dstname, ".htm" });
        defer ctx.allocator().free(srcpath);
        const dstpath = try util.joinIn(ctx.allocator(), &.{Context.params.SITE_PATH}, &.{ dstname, ".html" });
        defer ctx.allocator().free(dstpath);
        const rel_dstpath = try std.fs.path.relative(ctx.allocator(), Context.params.SITE_PATH, dstpath);
        defer ctx.allocator().free(rel_dstpath);

        log.debug("generating {s} at {s}", .{ p, rel_dstpath });

        if (std.fs.path.dirname(rel_dstpath)) |d| {
            const dstdir = try util.joinIn(ctx.allocator(), &.{Context.params.SITE_PATH}, &.{d});
            defer ctx.allocator().free(dstdir);

            try std.fs.cwd().makePath(dstdir);
        }

        const f = try std.fs.cwd().createFile(dstpath, .{});

        const page_name = try std.mem.replaceOwned(u8, ctx.allocator(), dstname, "_", " ");
        defer ctx.allocator().free(page_name);

        try build(ctx.allocator(), f, page_name, srcpath);
        ctx.generated += 1;
    }
}

// build a single html file
fn build(allocator: std.mem.Allocator, f: std.fs.File, page_name: []const u8, srcpath: []const u8) !void {
    const mtime = try util.getMtime(allocator, srcpath);
    defer allocator.free(mtime);

    // HEAD
    try f.writer().print(
        \\<!-- Generated file, do not edit, you may edit and discard {[SOURCE]s} :) -->
        \\<!DOCTYPE html>
        \\<html lang="en">
        \\<head>
        \\<meta charset="utf-8">
        \\<meta name="thumbnail" content="/media/services/thumbnail.jpg">
        \\<meta name="viewport" content="width=device-width,initial-scale=1">
        \\<link rel="alternate" type="application/rss+xml" title="RSS Feed" href="/links/rss.xml">
        \\<link rel="stylesheet" type="text/css" href="/links/main.css">
        \\<link rel="shortcut icon" type="image/png" href="/media/services/icon.png">
        \\<link rel="license" href="{[LICENSE_URL]s}">
        \\<title>{[SITE_NAME]s} &mdash; {[PAGE_NAME]s}</title>
        \\</head>
        \\<body>
        \\<header>
        \\<a href="/"><img src="/media/interface/logo.svg" alt="{[SITE_NAME]s}"></a>
        \\
    , .{
        .SOURCE = srcpath,
        .LICENSE_URL = Context.params.LICENSE_URL,
        .PAGE_NAME = page_name,
        .SITE_NAME = Context.params.SITE_NAME,
    });

    // NAV
    try f.writer().writeAll(
        \\<nav>
        \\
    );
    portal(allocator, f.writer().any(), "meta.nav", false) catch {}; // ignore error
    try f.writer().writeAll(
        \\</nav>
        \\</header>
        \\
    );

    // MAIN
    try f.writer().print(
        \\<main>
        \\
    , .{});
    try inject(allocator, f.writer().any(), srcpath);
    try f.writer().writeAll(
        \\</main>
        \\
    );

    // FOOTER
    try f.writer().print(
        \\<footer>
        \\Edited on {[MTIME]s} <a href="{[SOURCE_URL]s}/{[PATH]s}" target="_blank">[src]</a>
        \\<a href="mailto:{[PUBLIC_INBOX]s}">[comments]</a>
        \\<br>
        \\<b>{[LICENSE_HOLDER]s}</b>
        \\&copy; {[LICENSE_YEAR]s}
        \\&mdash;
        \\<a href="{[LICENSE_URL]s}" target="_blank">{[LICENSE_NAME]s}</a>
        \\</footer>
        \\
    , .{
        .LICENSE_HOLDER = Context.params.LICENSE_HOLDER,
        .LICENSE_NAME = Context.params.LICENSE_NAME,
        .LICENSE_URL = Context.params.LICENSE_URL,
        .LICENSE_YEAR = Context.params.LICENSE_YEAR,
        .MTIME = mtime,
        .PATH = srcpath,
        .PUBLIC_INBOX = Context.params.PUBLIC_INBOX,
        .SOURCE_URL = Context.params.SOURCE_URL,
    });

    try f.writer().writeAll(
        \\<a href="#top">[&#9206;]</a>
        \\
    );

    try f.writer().writeAll(
        \\</body>
        \\</html>
        \\
    );
}

// build a virtual html file, currently either:
// - meta.nav: used for populating the global navigation menu
// - meta.tilde: used to create ~foobar files
fn meta(ctx: *Context, p: []const u8) !void {
    ctx.meta += 1;

    if (std.mem.startsWith(u8, p, "meta.nav.")) return;

    if (std.mem.startsWith(u8, p, "meta.tilde.")) {
        const dot = std.mem.indexOfPosLinear(u8, p, 11, ".");
        const dstname = p[11..dot.?];
        const srcpath = try util.joinIn(ctx.allocator(), &.{Context.params.PAGE_PATH}, &.{p});
        defer ctx.allocator().free(srcpath);
        const dstpath = try util.joinIn(ctx.allocator(), &.{Context.params.LINK_PATH}, &.{ "~", dstname });
        defer ctx.allocator().free(dstpath);

        const link = blk: {
            const f = try std.fs.cwd().openFile(srcpath, .{ .mode = .read_only });
            defer f.close();
            const content = try f.readToEndAlloc(ctx.allocator(), std.os.linux.PATH_MAX);
            defer ctx.allocator().free(content);
            const trimmed = std.mem.trim(u8, content, " \n\t\r");
            break :blk try ctx.allocator().dupe(u8, trimmed);
        };
        defer ctx.allocator().free(link);

        const f = try std.fs.cwd().createFile(dstpath, .{});
        defer f.close();

        try f.writer().print(
            \\<!DOCTYPE html>
            \\<html lang="en">
            \\<head>
            \\<meta charset="utf-8">
            \\<meta http-equiv="refresh" content="0; url={[LINK]s}">
            \\<meta name="fediverse:creator" content="@robertgzr@toot.berlin">
            \\<link rel="stylesheet" type="text/css" href="links/main.css">
            \\</head>
            \\<body>
            \\<noscript>Continue to <a href="{[LINK]s}">{[LINK]s}</a>.</noscript>
            \\<script>
            \\'use strict'
            \\window.location.replace("{[LINK]s}")
            \\</script>
            \\</body>
            \\</html>
            \\
        , .{
            .LINK = link,
        });

        ctx.tilde += 1;
        return;
    }

    return error.unknownMeta;
}

// parses srcpath, resolves refs and portals and writes everything to w
fn inject(allocator: std.mem.Allocator, w: std.io.AnyWriter, srcpath: []const u8) !void {
    const inc = std.fs.cwd().openFile(srcpath, .{ .mode = .read_only }) catch |err| {
        if (err == error.FileNotFound)
            log.warn("Missing {s} include.", .{srcpath});

        return err;
    };
    defer inc.close();

    var buf_writer = std.io.bufferedWriter(w);
    var out_stream = buf_writer.writer();

    var buf_reader = std.io.bufferedReader(inc.reader());
    var in_stream = buf_reader.reader();

    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();

    while (in_stream.readUntilDelimiterOrEofAlloc(
        arena.allocator(),
        '\n',
        buf_reader.buf.len,
    ) catch {
        @panic("Failed to read from stream");
    }) |chunk_| {
        defer _ = arena.reset(.free_all);

        var chunk = chunk_;
        templating: while (true) {
            if (std.mem.indexOfPosLinear(u8, chunk, 0, "{")) |start| {
                if (std.mem.indexOfPosLinear(u8, chunk, start + 1, "}")) |end| {
                    try out_stream.writeAll(chunk[0..start]);
                    template(allocator, out_stream.any(), chunk[start + 1 .. end]) catch
                        @panic("Failed to resolve template");
                    chunk = chunk[end + 1 ..];
                } else break :templating;
            } else break :templating;
        }

        try out_stream.writeAll(chunk);
        try out_stream.writeByte('\n');
        try buf_writer.flush();
    }

    try buf_writer.flush();
}

// implements various reference types that can be used in .htm templates
fn template(allocator: std.mem.Allocator, w: std.io.AnyWriter, refname: []const u8) anyerror!void {
    switch (refname[0]) {
        '/' => return try portal(allocator, w, refname[1..], false),
        '@' => return try ref_link(allocator, w, refname[1..]),
        '+' => return try ref_name(allocator, w, refname[1..]),
        else => return try ref(allocator, w, refname),
    }
}

fn portal(allocator: std.mem.Allocator, w: std.io.AnyWriter, refname: []const u8, insert_heading: bool) anyerror!void {
    const basename = try std.mem.replaceOwned(u8, allocator, refname, " ", "_");
    defer allocator.free(basename);
    const refpathPage = try util.joinIn(allocator, &.{Context.params.PAGE_PATH}, &.{ basename, ".htm" });
    defer allocator.free(refpathPage);
    const refpathSite = try util.joinIn(allocator, &.{Context.params.SITE_PATH}, &.{ basename, ".html" });
    defer allocator.free(refpathSite);

    if (insert_heading)
        try w.print(
            \\<h2 id="{[ID]s}"><a href="/{[PATH]s}">{[NAME]s}</a></2>
            \\
        , .{
            .ID = basename,
            .NAME = refname,
            .PATH = refpathSite,
        });

    try inject(allocator, w, refpathPage);

    // XXX: track ref count?
}

fn ref(allocator: std.mem.Allocator, w: std.io.AnyWriter, refname: []const u8) anyerror!void {
    const basename = try std.mem.replaceOwned(u8, allocator, refname, " ", "_");
    defer allocator.free(basename);
    const refpathSite = try util.joinIn(allocator, &.{Context.params.SITE_PATH}, &.{ basename, ".html" });
    defer allocator.free(refpathSite);

    try w.print(
        \\<a href="/{[PATH]s}">{[NAME]s}</a>
    , .{
        .NAME = refname,
        .PATH = refpathSite,
    });

    // XXX: track ref count?
}

fn ref_link(allocator: std.mem.Allocator, w: std.io.AnyWriter, refname: []const u8) anyerror!void {
    const basename = try std.mem.replaceOwned(u8, allocator, refname, " ", "_");
    defer allocator.free(basename);
    const refpathSite = try util.joinIn(allocator, &.{Context.params.SITE_PATH}, &.{ basename, ".html" });
    defer allocator.free(refpathSite);

    try w.print("/{s}", .{refpathSite});
}

fn ref_name(_: std.mem.Allocator, w: std.io.AnyWriter, refname: []const u8) anyerror!void {
    try w.print("{s}", .{refname});
}

const util = struct {
    // also trims off base paths
    fn stripExt(path: []const u8) ![]const u8 {
        const ext = std.fs.path.extension(path);
        const ext_idx = std.mem.indexOfPosLinear(u8, path, 0, ext);
        std.debug.assert(ext_idx != null);
        return path[0..ext_idx.?];
    }

    fn joinIn(allocator: std.mem.Allocator, paths: []const []const u8, filename_parts: []const []const u8) ![]u8 {
        const filename = try std.mem.concat(allocator, u8, filename_parts);
        defer allocator.free(filename);

        var p = try std.ArrayList([]const u8).initCapacity(allocator, paths.len + 1);
        defer p.deinit();

        p.appendSliceAssumeCapacity(paths);
        p.appendAssumeCapacity(filename);

        const paths2 = try p.toOwnedSlice();
        defer allocator.free(paths2);

        std.debug.assert(paths.len + 1 == paths2.len);
        return try std.fs.path.join(allocator, paths2);
    }

    fn getMtime(allocator: std.mem.Allocator, srcpath: []const u8) ![]u8 {
        const attr = try allocator.create(std.os.linux.Stat);
        defer allocator.destroy(attr);
        const srcpathZ = try allocator.dupeZ(u8, srcpath);
        defer allocator.free(srcpathZ);
        _ = std.os.linux.stat(srcpathZ, attr);
        const mtime = attr.mtime();
        const mtime_str = try allocator.alloc(u8, 512);
        const n = c.strftime(
            mtime_str.ptr,
            mtime_str.len,
            "%F",
            c.localtime(&mtime.sec),
        );
        return try allocator.realloc(mtime_str, n);
    }
};