package main

import (
	"log"
	"net/http"
	"os"
	"time"

	messages "git.tornberg.me/go-cart-actor/proto"
)

func spawn(id CartId) (*CartGrain, error) {
	ret := &CartGrain{
		Id:              id,
		Items:           []CartItem{},
		storageMessages: []Message{},
		TotalPrice:      0,
	}
	err := loadMessages(ret, id)
	return ret, err
}

func init() {
	os.Mkdir("data", 0755)
}

type App struct {
	pool    *GrainLocalPool
	storage *DiskStorage
}

func (a *App) Save() error {
	for id, grain := range a.pool.GetGrains() {
		if grain == nil {
			continue
		}
		err := a.storage.Store(id, grain)
		if err != nil {
			log.Printf("Error saving grain %s: %v\n", id, err)
		}
	}
	return a.storage.saveState()
}

func (a *App) HandleSave(w http.ResponseWriter, r *http.Request) {
	err := a.Save()
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(err.Error()))
	} else {
		w.WriteHeader(http.StatusCreated)
	}
}

type PoolServer struct {
	pool GrainPool
}

func NewPoolServer(pool GrainPool) *PoolServer {
	return &PoolServer{
		pool: pool,
	}
}

func (s *PoolServer) HandleGet(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	data, err := s.pool.Get(ToCartId(id))
	if err != nil {
		w.WriteHeader(http.StatusNotFound)
		w.Write([]byte(err.Error()))
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(data)
}

func (s *PoolServer) HandleAddSku(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	sku := r.PathValue("sku")
	data, err := s.pool.Process(ToCartId(id), Message{
		Type:    AddRequestType,
		Content: &messages.AddRequest{Sku: sku},
	})
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(err.Error()))
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(data)
}

func (s *PoolServer) Serve() *http.ServeMux {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /{id}", s.HandleGet)
	mux.HandleFunc("GET /{id}/add/{sku}", s.HandleAddSku)
	return mux
}

func main() {
	// Create a new instance of the server
	storage, err := NewDiskStorage("data/state.gob")
	if err != nil {
		log.Printf("Error loading state: %v\n", err)
	}
	app := &App{
		pool:    NewGrainLocalPool(1000, 5*time.Minute, spawn),
		storage: storage,
	}

	rpcHandler, err := NewGrainHandler(app.pool, "localhost:1337")
	if err != nil {
		log.Fatalf("Error creating handler: %v\n", err)
	}
	go rpcHandler.Serve()

	remotePool := NewRemoteGrainPool("localhost:1337")
	remoteServer := NewPoolServer(remotePool)
	localServer := NewPoolServer(app.pool)
	mux := http.NewServeMux()
	mux.Handle("/remote/", http.StripPrefix("/remote", remoteServer.Serve()))
	mux.Handle("/local/", http.StripPrefix("/local", localServer.Serve()))
	mux.HandleFunc("GET /save", app.HandleSave)
	http.ListenAndServe(":8080", mux)

}