main.go

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"image"
	_ "image/jpeg"
	_ "image/png"
	"log"
	"net/http"
	"os"
	"strings"
)


// Add your allowed keys here
var allowedKeys = map[string]bool{
	"unkwn|9032748983":            true,
}

func loadAllowedKeys() {
	file, err := os.Open("allowed_keys.txt")
	if err != nil {
		log.Printf("Warning: Could not load allowed_keys.txt: %v", err)
		return
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		key := strings.TrimSpace(scanner.Text())
		if key != "" {
			allowedKeys[key] = true
		}
	}
}

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		key := r.Header.Get("x-api-key")
		if !allowedKeys[key] {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}
		next(w, r)
	}
}

type SolveResponse struct {
	X          int     `json:"x"`
	Y          int     `json:"y"`
	Confidence float64 `json:"confidence"`
}

func solveHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// Parse multipart form
	err := r.ParseMultipartForm(10 << 20) // 10 MB limit
	if err != nil {
		http.Error(w, "Failed to parse form", http.StatusBadRequest)
		return
	}

	bgFile, _, err := r.FormFile("background")
	if err != nil {
		http.Error(w, "Missing background image", http.StatusBadRequest)
		return
	}
	defer bgFile.Close()

	sliceFile, _, err := r.FormFile("piece")
	if err != nil {
		http.Error(w, "Missing piece image", http.StatusBadRequest)
		return
	}
	defer sliceFile.Close()

	bgImg, _, err := image.Decode(bgFile)
	if err != nil {
		http.Error(w, "Invalid background image", http.StatusBadRequest)
		return
	}

	sliceImg, _, err := image.Decode(sliceFile)
	if err != nil {
		http.Error(w, "Invalid piece image", http.StatusBadRequest)
		return
	}

	// Call Solve from solve.go
	pos, score, err := Solve(bgImg, sliceImg)
	if err != nil {
		http.Error(w, fmt.Sprintf("Solver error: %v", err), http.StatusInternalServerError)
		return
	}

	resp := SolveResponse{
		X:          pos.X,
		Y:          pos.Y,
		Confidence: score,
	}
	fmt.Println(resp)
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(resp)
}

func main() {
	http.HandleFunc("/solve", authMiddleware(solveHandler))

	port := "8085"
	fmt.Printf("Server starting on port %s...\n", port)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}