package logger

import (
	"database/sql"
	"fmt"
	"log"
	// "net/http"
	"strings"
	"sync"
	"time"

	_ "github.com/mattn/go-sqlite3"
)


var (
	Lite_db *sql.DB
	lite_dbMutex sync.Mutex

	logMutex sync.Mutex
	logLimit = 100
	// LogEntries []string
)

const (
    Debug   LogLevel = "debug"
    Info    LogLevel = "info"
    Warning LogLevel = "warning"
    Error   LogLevel = "error"
    Fatal   LogLevel = "fatal"
)

type LogLevel string

type LogEntry struct {
	Message 	string
	Timestamp 	string
	Level 		LogLevel
}

func ToLog(logLine string) string {
	log := fmt.Sprintf("%s",time.Now().Format(time.RFC3339) + " " + logLine)
	return log
}

func InitDB(dbPath string) error {
	var err error
	Lite_db, err = sql.Open("sqlite3", dbPath)
	if err != nil {
		return fmt.Errorf("Error opening DB: %w", err)
	}

	CreateTableQuery := `CREATE TABLE IF NOT EXISTS logs (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		message TEXT,
		timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
		level TEXT
	);`

	_, err = Lite_db.Exec(CreateTableQuery)
	if err != nil {
		return fmt.Errorf("Error creating table: %w", err)
	}

	return nil
}

func InsertLog(level LogLevel, message string) error {
	lite_dbMutex.Lock()
	defer lite_dbMutex.Unlock()

	// Future use may fulfill multiple transactions, a transaction is used
	tx, err := Lite_db.Begin()
	if err != nil {
		return fmt.Errorf("Error starting transaction: %w", err)
	}

	message = strings.ReplaceAll(message, `"`, `\"`)

	// insertQuery := `INSERT INTO logs (message) VALUES (?)`
	insertQuery := `INSERT INTO logs (message, level) VALUES (?, ?)`
	// _, err := Lite_db.Exec(insertQuery, message, level)
	_, err = tx.Exec(insertQuery, message, level)

	if err != nil {
		tx.Rollback()
		return fmt.Errorf("Error inserting log: %v", err)
	}

	err = tx.Commit()
	if err != nil {
		return fmt.Errorf("Error committing transaction: %w", err)
	}

	return nil
}

func FetchLogs(limit int) ([]LogEntry, error) {
	lite_dbMutex.Lock()
	defer lite_dbMutex.Unlock()

	query := `SELECT timestamp, level, message FROM logs ORDER BY timestamp DESC LIMIT ?`
	rows, err := Lite_db.Query(query, limit)
	if err != nil {
		return  nil, fmt.Errorf("Error fetching logs: %w", err)
	}
	defer rows.Close()

	// var logs []string
	var logs []LogEntry
	for rows.Next() {
		// var message string
		var logEntry LogEntry
		if err := rows.Scan( &logEntry.Timestamp, &logEntry.Level, &logEntry.Message); err != nil {
			return nil, fmt.Errorf("Error scanning row: %w", err)
		}
		logs = append(logs, logEntry)
	}

	return logs, nil
}

func CloseDB() {
	if Lite_db != nil {
		err := Lite_db.Close()
		if err != nil {
			log.Printf("Error closing database: %v", err)
		}
	}
}