package main

import (
	"bufio"
	"errors"
	"fmt"
	"net"
	"os"
	"strings"
	"time"
)


var db RedisDB

type handlerFunc func(net.Conn, []string)

var commandRegistry = map[string]handlerFunc{
    "GET":      handleGet,
    "SET":      handleSet,
    "DEL":      handleDel,
    "EXISTS":   handleExists,
    "INCR":     handleIncr,
    "DECR":     handleDecr,
    "PING":     handlePing,
    "FLUSHALL": handleFlushall,
    "RPUSH":    handleRpush,
	"LPUSH":	handleLpush,
    "LRANGE":   handleLrange,
    "LPOP":     handleLpop,
    "RPOP":     handleRpop,
	"EXPIRE":	handleExpire,
	"HSET":		handleHset,
	"HGET":		handleHget,
	"HGETALL":	handleHgetall,
	"HKEYS":	handleHkeys,
	"HVALUES":	handleHvalues,
	"TYPE":		handleType,
	"DBSIZE":	handleDbsize,
}

func main() {
	db = RedisDB{data: make(map[string]Item)}

	go func() {
		ticker := time.NewTicker(1 * time.Second)
		for range ticker.C {
			db.mu.Lock()
			for k, v := range db.data {
				if v.ExpiresAt != nil && time.Now().After(*v.ExpiresAt) {
					delete(db.data, k)
				}
			}
			db.mu.Unlock()
		}
	}()

	listener, err := net.Listen("tcp", ":6379")
	if err != nil {
		fmt.Println("error starting server: ", err)
		os.Exit(1)
	}
	defer listener.Close()
	fmt.Println("Redis clone listening on port 6379...")

	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			continue
		}
		go handleConnection(conn)
	}
}

func handleConnection(conn net.Conn) {
	defer conn.Close()
	fmt.Println("Client connected:", conn.RemoteAddr())

	reader := bufio.NewReader(conn)
	for {
		args, err := parseRESP(reader)
		if err != nil {
			fmt.Println("Client disconnected or error parsing:", conn.RemoteAddr(), err)
			return
		}

		if len(args) == 0 {
			continue
		}

		fmt.Printf("Parsed RESP Arguments: %v\n", args)

		command := strings.ToUpper(args[0])

		if handler, ok := commandRegistry[command]; ok {
            handler(conn, args)
        } else {
            conn.Write(serializeRESP(errors.New("unknown command")))
        }
		
	}
}