package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strings"
	"sync"
	"time"
)

type User struct {
	ID        int       `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email"`
	Active    bool      `json:"active"`
	CreatedAt time.Time `json:"created_at"`
}

type UserService struct {
	mu    sync.RWMutex
	users map[int]*User
}

func NewUserService() *UserService {
	return &UserService{
		users: make(map[int]*User),
	}
}

func (s *UserService) Add(user *User) error {
	s.mu.Lock()
	defer s.mu.Unlock()

	if user.Name == "" {
		return errors.New("name is required")
	}
	if !strings.Contains(user.Email, "@") {
		return errors.New("invalid email")
	}
	if _, exists := s.users[user.ID]; exists {
		return errors.New("user already exists")
	}
	s.users[user.ID] = user
	return nil
}

func (s *UserService) FindByID(id int) (*User, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()

	user, ok := s.users[id]
	if !ok {
		return nil, fmt.Errorf("user %d not found", id)
	}
	return user, nil
}

func (s *UserService) FindByEmail(email string) *User {
	s.mu.RLock()
	defer s.mu.RUnlock()

	for _, u := range s.users {
		if u.Email == email {
			return u
		}
	}
	return nil
}

func (s *UserService) All() []*User {
	s.mu.RLock()
	defer s.mu.RUnlock()

	result := make([]*User, 0, len(s.users))
	for _, u := range s.users {
		result = append(result, u)
	}
	return result
}

func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		log.Printf("%s %s %s", r.Method, r.URL.Path, r.RemoteAddr)
		next.ServeHTTP(w, r)
		log.Printf("%s completed in %v", r.URL.Path, time.Since(start))
	})
}

func handleUsers(svc *UserService) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")

		switch r.Method {
		case http.MethodGet:
			users := svc.All()
			json.NewEncoder(w).Encode(users)

		case http.MethodPost:
			var user User
			if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
			if err := svc.Add(&user); err != nil {
				http.Error(w, err.Error(), http.StatusConflict)
				return
			}
			w.WriteHeader(http.StatusCreated)
			json.NewEncoder(w).Encode(user)

		default:
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		}
	}
}

func main() {
	svc := NewUserService()
	svc.Add(&User{
		ID:    1,
		Name:  "Alice",
		Email: "alice@example.com",
		Active: true,
	})

	mux := http.NewServeMux()
	mux.HandleFunc("/users", handleUsers(svc))

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	server := &http.Server{
		Addr:         ":" + port,
		Handler:      loggingMiddleware(mux),
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	log.Printf("Server starting on :%s", port)
	log.Fatal(server.ListenAndServe())
}