chatservice_concept/api/db.go

package api

import (
	"errors"
	"fmt"
	"time"

	"git.dubyatp.xyz/chat-api-server/db"
)

func dbGetUser(id string) (*User, error) {
	data := db.ExecDB("users")
	if data == nil {
		return nil, errors.New("failed to load users database")
	}

	users := data["users"].([]interface{})
	for _, u := range users {
		user := u.(map[string]interface{})
		if user["ID"].(string) == id {
			return &User{
				ID:       user["ID"].(string),
				Name:     user["Name"].(string),
				Password: user["Password"].(string),
			}, nil
		}
	}
	return nil, errors.New("User not found")
}

func dbGetUserByName(username string) (*User, error) {
	data := db.ExecDB("users")
	if data == nil {
		return nil, errors.New("failed to load users database")
	}

	users := data["users"].([]interface{})
	for _, u := range users {
		user := u.(map[string]interface{})
		if user["Name"].(string) == username {
			return &User{
				ID:       user["ID"].(string),
				Name:     user["Name"].(string),
				Password: user["Password"].(string),
			}, nil
		}
	}
	return nil, errors.New("User not found")
}

func dbGetAllUsers() ([]*User, error) {
	data := db.ExecDB("users")
	if data == nil {
		return nil, errors.New("failed to load users database")
	}

	users := data["users"].([]interface{})
	var result []*User
	for _, u := range users {
		user := u.(map[string]interface{})
		result = append(result, &User{
			ID:   user["ID"].(string),
			Name: user["Name"].(string),
		})
	}
	if len(result) == 0 {
		return nil, errors.New("no users found")
	}
	return result, nil
}

func dbGetMessage(id string) (*Message, error) {
	data := db.ExecDB("messages")
	if data == nil {
		return nil, errors.New("failed to load messages database")
	}

	messages := data["messages"].([]interface{})
	for _, m := range messages {
		message := m.(map[string]interface{})
		if message["ID"].(string) == id {
			timestamp, err := time.Parse(time.RFC3339, message["Timestamp"].(string))
			if err != nil {
				return nil, fmt.Errorf("failed to parse timestamp: %v", err)
			}
			editedStr, ok := message["Edited"].(string)
			var edited time.Time
			if ok && editedStr != "" {
				var err error
				edited, err = time.Parse(time.RFC3339, editedStr)
				if err != nil {
					return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
				}
			}
			return &Message{
				ID:        message["ID"].(string),
				UserID:    message["UserID"].(string),
				Body:      message["Body"].(string),
				Timestamp: timestamp,
				Edited:    edited,
			}, nil
		}
	}
	return nil, errors.New("Message not found")
}

func dbGetAllMessages() ([]*Message, error) {
	data := db.ExecDB("messages")
	//println(data)
	if data == nil {
		return nil, errors.New("failed to load messages database")
	}

	messages := data["messages"].([]interface{})
	var result []*Message
	for _, m := range messages {
		message := m.(map[string]interface{})
		timestamp, err := time.Parse(time.RFC3339, message["Timestamp"].(string))
		if err != nil {
			return nil, fmt.Errorf("failed to parse timestamp: %v", err)
		}
		editedStr, ok := message["Edited"].(string)
		var edited time.Time
		if ok && editedStr != "" {
			var err error
			edited, err = time.Parse(time.RFC3339, editedStr)
			if err != nil {
				return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
			}
		}
		result = append(result, &Message{
			ID:        message["ID"].(string),
			UserID:    message["UserID"].(string),
			Body:      message["Body"].(string),
			Timestamp: timestamp,
			Edited:    edited,
		})
	}
	if len(result) == 0 {
		return nil, errors.New("no messages found")
	}
	return result, nil
}

func dbAddUser(user *User) error {
	currentData := db.ExecDB("users")
	if currentData == nil {
		return fmt.Errorf("error reading users database")
	}

	users, ok := currentData["users"].([]interface{})
	if !ok {
		return fmt.Errorf("users data is in an unexpected format")
	}

	dbUser := map[string]interface{}{
		"ID":       user.ID,
		"Name":     user.Name,
		"Password": user.Password,
	}

	users = append(users, dbUser)
	return db.WriteDB("users", users)
}

func dbAddMessage(message *Message) error {
	currentData := db.ExecDB("messages")
	if currentData == nil {
		return fmt.Errorf("error reading messages database")
	}

	messages, ok := currentData["messages"].([]interface{})
	if !ok {
		return fmt.Errorf("messages data is in an unexpected format")
	}

	var edited interface{}
	if message.Edited.IsZero() {
		edited = nil // Set to nil if Edited is the zero value
	} else {
		edited = message.Edited.Format(time.RFC3339)
	}

	dbMessage := map[string]interface{}{
		"ID":        message.ID,
		"UserID":    message.UserID, // JSON numbers are float64
		"Body":      message.Body,
		"Timestamp": message.Timestamp.Format(time.RFC3339),
		"Edited":    edited,
	}

	messages = append(messages, dbMessage)
	return db.WriteDB("messages", messages)
}

func dbUpdateMessage(updatedMessage *Message) error {
	currentData := db.ExecDB("messages")
	if currentData == nil {
		return fmt.Errorf("error reading messages database")
	}

	messages, ok := currentData["messages"].([]interface{})
	if !ok {
		return fmt.Errorf("messages data is in an unexpected format")
	}

	var updatedMessages []interface{}
	found := false

	for _, m := range messages {
		message, ok := m.(map[string]interface{})
		if !ok {
			continue
		}

		if messageID, ok := message["ID"].(string); ok && messageID == updatedMessage.ID {
			found = true

			var edited interface{}
			if updatedMessage.Edited.IsZero() {
				edited = nil // Set to nil if Edited is the zero value
			} else {
				edited = updatedMessage.Edited.Format(time.RFC3339)
			}

			message = map[string]interface{}{
				"ID":        updatedMessage.ID,
				"UserID":    updatedMessage.UserID,
				"Body":      updatedMessage.Body,
				"Timestamp": updatedMessage.Timestamp.Format(time.RFC3339),
				"Edited":    edited,
			}
		}
		updatedMessages = append(updatedMessages, message)
	}

	if !found {
		return fmt.Errorf("message with ID %s not found", updatedMessage.ID)
	}

	return db.WriteDB("messages", updatedMessages)
}

func dbDeleteMessage(id string) error {
	currentData := db.ExecDB("messages")
	if currentData == nil {
		return fmt.Errorf("error reading messages database")
	}

	messages, ok := currentData["messages"].([]interface{})
	if !ok {
		return fmt.Errorf("messages data is in an unexpected format")
	}

	var updatedMessages []interface{}
	found := false

	for _, m := range messages {
		message, ok := m.(map[string]interface{})
		if !ok {
			continue
		}

		if messageID, ok := message["ID"].(string); ok && messageID == id {
			found = true
			continue
		}

		updatedMessages = append(updatedMessages, message)
	}

	if !found {
		return fmt.Errorf("message with ID %s not found", id)
	}

	return db.WriteDB("messages", updatedMessages)
}