main.go

package main

import (
	"encoding/json"
	"expvar"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"context"
	"time"

	"github.com/gorilla/mux"
	github "nlp.go/git"
	"nlp.go/stemmer"
	nlp "nlp.go/token"
)

var (
	numTok = expvar.NewInt("token_caller")
)


func main() {

	logger := log.New(log.Writer(), "apis ", log.LstdFlags|log.Lshortfile)

	s := Server{
		logger: logger,
	}

	r := mux.NewRouter()
	r.HandleFunc("/health", s.healthHandler).Methods(http.MethodGet)
	r.HandleFunc("/token", s.tokenizeHandler).Methods(http.MethodPost)
	r.HandleFunc("/", s.landingHandler).Methods(http.MethodGet)
	r.HandleFunc("/stem/{word}", s.stemHandler).Methods(http.MethodPost)
	r.HandleFunc("/git/{username}", s.githubHandler).Methods(http.MethodPost)

	http.Handle("/", r)

	addr := os.Getenv("ADDR")
	if addr == "" {
		addr = ":8080"
	}
	logger.Printf("starting the api on port %s", addr)
	logger.Printf("api running on http://localhost:8080")
	if err := http.ListenAndServe(addr, nil); err != nil {
		log.Fatalf("error: %s", err)
	}
}

type Server struct {
	logger *log.Logger
}


func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
	s.logger.Print("Get request to '/health'")
	fmt.Fprint(w, "Bankai")
}


func (s *Server) stemHandler(w http.ResponseWriter, r *http.Request) {
	s.logger.Printf("Post request to '/stem{%s}'", mux.Vars(r)["word"])
	vars := mux.Vars(r)
	word := vars["word"]
	stem := stemmer.Stem(word)
	fmt.Fprintln(w, stem)
}


func (s *Server) landingHandler(w http.ResponseWriter, r *http.Request) {
	s.logger.Print("Get request to '/'")
	fmt.Fprintln(w, "This is the landing page")
}


func (s *Server) tokenizeHandler(w http.ResponseWriter, r *http.Request) {
	s.logger.Print("Post request to '/token' ")

	defer r.Body.Close()
	rdr := io.LimitReader(r.Body, 1_000_000)
	data, err := io.ReadAll(rdr)
	if err != nil {
		http.Error(w, "Can't read", http.StatusBadRequest)
		return
	}

	if len(data) == 0 {
		http.Error(w, "missing data", http.StatusBadRequest)
		return
	}
	text := string(data)

	token := nlp.Tokenize(text)

	resp := map[string]any{
		"tokens": token,
	}
	data, err = json.Marshal(resp)
	if err != nil {
		http.Error(w, "Can't encode", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.Write(data)

	numTok.Add(1)
}


func (s *Server) githubHandler(w http.ResponseWriter, r *http.Request) {
	s.logger.Printf("Post request to '/git/{%s}'", mux.Vars(r)["username"])
	username := mux.Vars(r)["username"]

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	name, repos, err := github.Getgitprofiile(ctx, username)

	if err != nil{
		s.logger.Printf("An error occured while trying to get user details on github %s", err)
		fmt.Fprint(w, "Unable to receive user details try again later")
		return
	}

	resp := map[string]any{
		"Name": name,
		"Number of repos": repos,
	}

	data, err := json.Marshal(resp)

	if err != nil{
		s.logger.Printf("Error while decoding the response %s", err)
		http.Error(w, "Can't encode", http.StatusInternalServerError)
		return
	}

	w.Write(data)

}