comments_engine/main.go

package main

import (
	"bytes"
	"database/sql"
	"fmt"
	"html/template"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"time"

	"github.com/Masterminds/sprig/v3"

	"github.com/yuin/goldmark"
	_ "modernc.org/sqlite"
)

type Message struct {
	Message_id int64
	Message template.HTML
	parent_message sql.NullInt64
	Username string
	message_time int64
	Message_time string
	Children []Message
}
var db_pool *sql.DB

func main() {
	var err error
	db_pool, err = sql.Open("sqlite", "db.sqlite")
	if err != nil {
		log.Fatal(err.Error());
	}
	defer db_pool.Close()
	db_pool.SetMaxIdleConns(3)
	db_pool.SetMaxOpenConns(3)
	db_pool.SetConnMaxLifetime(0)
	create_schema()
	

	router := http.NewServeMux();
	router.HandleFunc("POST /key/{page_id}/reply/{message_id}/", answer_message)
	router.HandleFunc("POST /key/{page_id}/", send_message)
	router.HandleFunc("GET /key/{page_id}/", get_messages)
	router.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request){http.ServeFileFS(w, r, os.DirFS("templates"), "index.html")})
	router.HandleFunc("GET /style.css", func(w http.ResponseWriter, r *http.Request){http.ServeFileFS(w, r, os.DirFS("templates"), "style.css")})
	fmt.Print("Listening at :8080")
	log.Fatal(http.ListenAndServe(":8080", router))

}

func create_schema() {
	schema, _ := os.ReadFile("schema.sql")
	fmt.Println(string(schema))
	_, err := db_pool.Exec(string(schema))
	if err != nil {
		err_str := err.Error();
		if err_str != "SQL logic error: table \"Messages\" already exists (1)" && err_str != "SQL logic error: table \"Boards\" already exists (1)" {
			fmt.Println(err.Error())
			log.Fatal(err.Error())
		}
	}
}

func send_message (writer http.ResponseWriter, request *http.Request) {
	if err := request.ParseForm(); err != nil {
		log.Println(err.Error());
		return
	}
	username := request.PostForm["username"][0]
	message_md := request.PostForm["message"][0]
	page_id := request.PathValue("page_id")
	var message_html bytes.Buffer
	if err := goldmark.Convert([]byte(message_md), &message_html); err != nil {
		log.Println(err.Error())
		writer.WriteHeader(http.StatusBadRequest)
		return
	}
	stmt, err := db_pool.Prepare(`
		INSERT INTO Boards (board_name)
		SELECT $1
		WHERE NOT EXISTS (
			SELECT 1 FROM Boards WHERE board_name = $1
		);

		SELECT board_id FROM Boards WHERE board_name = $1;
		INSERT INTO Messages (board_id, message, username, message_date)
		VALUES ( (SELECT board_id FROM Boards WHERE board_name = $1), $2, $3, $4 )
	`)
	defer stmt.Close()
	if _, err = stmt.Exec(
		page_id, 
		message_html.Bytes(), 
		username, 
		time.Now().Unix()); err != nil {
		log.Println(err.Error())
		return 
	}

	log.Println("Send message")
	http.Redirect(writer, request, fmt.Sprintf("/key/%s/", page_id), http.StatusSeeOther)

	io.WriteString(writer, "Success")
}

func answer_message (writer http.ResponseWriter, request *http.Request) {
	if err := request.ParseForm(); err != nil {
		log.Println(err.Error());
		return
	}
	username := request.PostForm["username"][0]
	message_md := request.PostForm["message"][0]
	parent_message := request.PathValue("message_id")
	page_id := request.PathValue("page_id")
	var message_html bytes.Buffer
	if err := goldmark.Convert([]byte(message_md), &message_html); err != nil {
		log.Println(err.Error())
		writer.WriteHeader(http.StatusBadRequest)
		return
	}
	stmt, err := db_pool.Prepare(`
	 	INSERT  INTO Messages (board_id, parent_message_id, message, username, message_date)
		VALUES ( (SELECT board_id FROM Boards WHERE board_name = $1), $2, $3, $4, $5 )
	`)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer stmt.Close()
	if _, err = stmt.Exec(
		page_id,
		parent_message, 
		message_html.Bytes(), 
		username, 
		time.Now().Unix()); err != nil {
		log.Println(err.Error())
		return
	}
	log.Println("Answer message")
	http.Redirect(writer, request, fmt.Sprintf("/key/%s/", page_id), http.StatusSeeOther)
}

func get_messages (writer http.ResponseWriter, request *http.Request) {
	rows, err := db_pool.Query(`
	SELECT * FROM Messages WHERE board_id=(SELECT board_id FROM Boards WHERE board_name = ?)
	ORDER BY parent_message_id
	`, request.PathValue("page_id"))
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer rows.Close()
	var messages []Message

	for rows.Next() {
		next_message := Message{}
		var board_id sql.NullInt64
		if err := rows.Scan(
			&next_message.Message_id,
			&board_id,
			&next_message.parent_message,
			&next_message.Message,
			&next_message.Username,
			&next_message.message_time,
		); err != nil {
			log.Println(err.Error())
			continue
		}
		next_message.Message_time = time.Unix(next_message.message_time,0).Format("1/2/2006 at 3:04 PM UTC")
		messages = add_message_to_tree(messages, next_message)
	}
	tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseFiles("templates/feed.html")
	if err != nil {
		log.Printf("Error parsing template: %v", err)
	}
	if err = tmpl.ExecuteTemplate(writer, filepath.Base("templates/feed.html") , struct {
		Messages []Message 
		Page_name string
	}{
		Messages: messages,
		Page_name: request.PathValue("page_id"),
	} ); err != nil {
		log.Println(err.Error())
		return
	}
}

func add_message_to_tree(messages []Message, message Message) []Message {
	if !message.parent_message.Valid {
		messages = append(messages, message)
		return messages
	}
	for parent_message_index := range messages {
		if add_message_to_tree_recursive(&messages[parent_message_index] , message) {
			return messages
		}
	}
	log.Println("Not found")
	return messages
}
func add_message_to_tree_recursive(parent *Message, message Message) bool {
	if parent.Message_id == message.parent_message.Int64 {
		parent.Children = append(parent.Children, message)
		return true
	}
	for child_index := range parent.Children {
		if add_message_to_tree_recursive(&parent.Children[child_index], message) {
			return true
		}
	}
	return false
}