package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"user-svc/user"

	"google.golang.org/grpc"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type User struct {
	ID       string `json:"id" gorm:"primaryKey"`
	Name     string `json:"name"`
	Email    string `json:"email"`
	Password string `json:"password"`
}

type UserServiceServer struct {
	user.UnimplementedUserServiceServer
	db *gorm.DB
}

func (s *UserServiceServer) CreateUser(ctx context.Context, req *user.CreateUserRequest) (*user.CreateUserResponse, error) {
	newUser := User{
		ID:       fmt.Sprintf("%d", len(s.getAllUsers())+1),
		Name:     req.Name,
		Email:    req.Email,
		Password: req.Password,
	}

	result := s.db.Create(&newUser)
	if result.Error != nil {
		return nil, result.Error
	}

	return &user.CreateUserResponse{
		User: &user.User{
			Id:       newUser.ID,
			Name:     newUser.Name,
			Email:    newUser.Email,
			Password: newUser.Password,
		},
	}, nil
}

func (s *UserServiceServer) GetUser(ctx context.Context, req *user.GetUserRequest) (*user.GetUserResponse, error) {
	var user User
	result := s.db.First(&user, "id = ?", req.Id)
	if result.Error != nil {
		return nil, result.Error
	}

	return &user.GetUserResponse{
		User: &user.User{
			Id:       user.ID,
			Name:     user.Name,
			Email:    user.Email,
			Password: user.Password,
		},
	}, nil
}

func (s *UserServiceServer) ListUsers(ctx context.Context, req *user.ListUsersRequest) (*user.ListUsersResponse, error) {
	users := s.getAllUsers()
	var protoUsers []*user.User

	for _, u := range users {
		protoUsers = append(protoUsers, &user.User{
			Id:       u.ID,
			Name:     u.Name,
			Email:    u.Email,
			Password: u.Password,
		})
	}

	return &user.ListUsersResponse{
		Users: protoUsers,
	}, nil
}

func (s *UserServiceServer) UpdateUser(ctx context.Context, req *user.UpdateUserRequest) (*user.UpdateUserResponse, error) {
	var user User
	result := s.db.First(&user, "id = ?", req.Id)
	if result.Error != nil {
		return nil, result.Error
	}

	if req.Name != "" {
		user.Name = req.Name
	}
	if req.Email != "" {
		user.Email = req.Email
	}
	if req.Password != "" {
		user.Password = req.Password
	}

	s.db.Save(&user)

	return &user.UpdateUserResponse{
		User: &user.User{
			Id:       user.ID,
			Name:     user.Name,
			Email:    user.Email,
			Password: user.Password,
		},
	}, nil
}

func (s *UserServiceServer) DeleteUser(ctx context.Context, req *user.DeleteUserRequest) (*user.DeleteUserResponse, error) {
	result := s.db.Delete(&User{}, "id = ?", req.Id)
	if result.Error != nil {
		return nil, result.Error
	}

	return &user.DeleteUserResponse{
		Success: true,
	}, nil
}

func (s *UserServiceServer) getAllUsers() []User {
	var users []User
	s.db.Find(&users)
	return users
}

func initDB() *gorm.DB {
	db, err := gorm.Open(sqlite.Open("users.db"), &gorm.Config{})
	if err != nil {
		log.Fatalf("Failed to connect to database: %v", err)
	}

	db.AutoMigrate(&User{})
	return db
}

func main() {
	db := initDB()

	server := grpc.NewServer()
	user.RegisterUserServiceServer(server, &UserServiceServer{db: db})

	listener, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	log.Println("User service starting on port 50051...")
	if err := server.Serve(listener); err != nil {
		log.Fatalf("Failed to serve: %v", err)
	}
}