package eu.m724.blog.data;

import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.*;
import java.util.HashMap;
import java.util.Map;

/**
 * The {@code Post} class represents a blog post with various attributes including metadata and content.
 *
 * @param slug A unique identifier for the post derived from the file name.
 * @param title The title of the post.
 * @param summary A brief summary of the post content.
 * @param draft Indicates whether the post is marked as a draft or published.
 * @param revisions The number of revisions the post has undergone in version control.
 * @param createdBy The name of the author who created the post.
 * @param createdAt The timestamp of when the post was first created.
 * @param modifiedBy The name of the author who last modified the post.
 * @param modifiedAt The timestamp of the last modification to the post.
 * @param custom A map of custom properties or metadata associated with the post.
 * @param rawContent The raw content of the post, which <em>currently</em> is usually HTML.
 */
public record Post(
        String slug,
        String title,
        String summary,
        boolean draft,

        int revisions,
        String createdBy,
        ZonedDateTime createdAt,
        String modifiedBy,
        ZonedDateTime modifiedAt,

        Map<String, String> custom,
        String rawContent
) {
    private static final Logger LOGGER = LoggerFactory.getLogger(Post.class);

    /**
     * Creates a {@link Post} instance by reading and parsing the content of a post file.
     * <p>
     * The method extracts metadata properties, content, and versioning information
     * based on the Git history of the file.
     *
     * @param git the Git repository used to retrieve versioning and commit information
     * @param path the relative path to the file within the "posts" directory
     * @return a {@link Post} object populated with data extracted from the specified file
     * @throws IOException if an error occurs during file reading
     */
    public static Post fromFile(Git git, Path path) throws IOException {
        /* read properties before filtering */

        var slug = path.getFileName().toString().split("\\.")[0];
        path = Path.of("posts").resolve(path);
        var lines = Files.readAllLines(git.getRepository().getDirectory().toPath().getParent().resolve(path));

        var properties = new HashMap<String, String>();

        while (!lines.isEmpty()) {
            var line = lines.removeFirst();
            var parts = line.split(" ");

            var key = parts[0].toLowerCase();
            var data = line.substring(key.length()).strip();

            if (key.isEmpty()) // empty key means end of content
                break;

            if (properties.putIfAbsent(key, data) != null)
                LOGGER.warn("[Post {}] Ignoring duplicate property: {}", slug, key);
        }

        var content = String.join("\n", lines).strip();

        /* filter properties from read file */

        String title = "NO TITLE SET";
        String summary = "NO SUMMARY SET";
        boolean draft = true;

        var custom = new HashMap<String, String>();

        for (Map.Entry<String, String> property : properties.entrySet()) {
            var value = property.getValue();

            switch (property.getKey()) {
                case "title":
                    title = value;
                    break;
                case "summary":
                    summary = value;
                    break;
                case "live": // a post is live (not draft) if the key is there
                    draft = false;
                    break;
                default:
                    custom.put(property.getKey(), value);
            }
        }

        /* get revisions */

        int revisions = 0;
        String createdBy = "UNKNOWN AUTHOR";
        ZonedDateTime createdAt = Instant.ofEpochMilli(0).atZone(ZoneOffset.UTC);
        String modifiedBy = "UNKNOWN AUTHOR";
        ZonedDateTime modifiedAt = Instant.ofEpochMilli(0).atZone(ZoneOffset.UTC);

        try {
            for (var commit : git.log().addPath(path.toString()).call()) {
                createdBy = commit.getAuthorIdent().getName();
                createdAt = Instant.ofEpochSecond(commit.getCommitTime()).atZone(ZoneOffset.UTC);

                if (revisions++ == 0) {
                    modifiedBy = createdBy;
                    modifiedAt = createdAt;
                }
            }
        } catch (GitAPIException e) {
            draft = true;
            LOGGER.warn("[Post {}] Draft because of a Git exception: {}", slug, e.getMessage());
        }

        return new Post(slug, title, summary, draft, revisions, createdBy, createdAt, modifiedBy, modifiedAt, custom, content);
    }

    /**
     * Retrieves the raw HTML content associated with the post.
     *
     * @return the raw HTML content as a string
     */
    public String htmlContent() {
        return rawContent;
    }
}