cronnoss / tk-api

import (

	"context"

	"encoding/json"

	"fmt"

	"io"

	"net"

	"net/http"

	"time"

	_ "github.com/cronnoss/tickets-api/docs" // nolint: revive

	"github.com/cronnoss/tk-api/internal/common/srv"

	"github.com/cronnoss/tk-api/internal/model"

	"github.com/cronnoss/tk-api/internal/server"

	"github.com/cronnoss/tk-api/internal/storage/models"

	"github.com/gorilla/mux"

	httpSwagger "github.com/swaggo/http-swagger"

)

type ctxKeyID int

const (

	KeyLoggerID ctxKeyID = iota

)

type Server struct {

	srv  http.Server

	app  server.Application

	log  Logger

	host string

	port string

}

type Logger interface {

	Fatalf(format string, a ...interface{})

	Errorf(format string, a ...interface{})

	Warningf(format string, a ...interface{})

	Infof(format string, a ...interface{})

	Debugf(format string, a ...interface{})

}

func NewServer(log Logger, app server.Application, host, port string) *Server {

	return &Server{log: log, app: app, host: host, port: port}

}

func (s *Server) helperDecode(stream io.ReadCloser, w http.ResponseWriter, data interface{}) error { // nolint: unused

	decoder := json.NewDecoder(stream)

	if err := decoder.Decode(&data); err != nil {

		s.log.Errorf("Can't decode json:%v\n", err)

		w.WriteHeader(http.StatusBadRequest)

		w.Write([]byte(fmt.Sprintf("{\"error\": \"Can't decode json:%v\"}\n", err)))

		return err

	}

	return nil

}

// @Summary Get shows

// @Tags shows

// @Description Get shows from remote API and store them in the local service

// @ID get-shows

// @Accept  json

// @Produce  json

// @Success 200 {object} ShowListResponse

// @Failure 400,404 {object} server.ErrorResponse

// @Failure 500 {object} server.ErrorResponse

// @Router /shows [get].

// @Summary Get events

// @Tags events

// @Description Get events by show ID

// @ID get-events

// @Accept  json

// @Produce  json

// @Param id path int true "show ID"

// @Success 200 {object} EventListResponse

// @Failure 400,404 {object} server.ErrorResponse

// @Failure 500 {object} server.ErrorResponse

// @Router /shows/{id}/events [get].

func (s *Server) GetEvents(w http.ResponseWriter, r *http.Request) {

	// Step 1: Make a GET request to the remote API

	vars := mux.Vars(r)

	id := vars["id"]

	remoteURL := "https://leadbook.ru/test-task-api/shows/" + id + "/events"

	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, remoteURL, nil)

	if err != nil {

		return

	}

	resp, err := http.DefaultClient.Do(req)

	if err != nil {

		return

	}

	defer resp.Body.Close()

	// Step 2: Decode the response

	body, err := io.ReadAll(resp.Body)

	if err != nil {

		return

	}

	var eventListResponse model.EventListResponse

	if err := json.Unmarshal(body, &eventListResponse); err != nil {

		return

	}

	// Step 3: Iterate over events and store them in the local service

	for _, event := range eventListResponse.Response {

		if err := eventListResponse.EventListResponseValidate(); err != nil {

			return

		}

		_, err := s.app.CreateEvent(r.Context(), models.Event{

			ID:     event.ID,

			ShowID: event.ShowID,

			Date:   event.Date,

		})

		if err != nil {

			return

		}

	}

	srv.RespondOK(eventListResponse.Response, w, r)

}

// @Summary Get places

// @Tags places

// @Description Get places by event ID

// @ID get-places

// @Accept  json

// @Produce  json

// @Param id path int true "event ID"

// @Success 200 {object} PlaceListResponse

// @Failure 400,404 {object} server.ErrorResponse

// @Failure 500 {object} server.ErrorResponse

// @Router /events/{id}/places [get].

func (s *Server) GetPlaces(w http.ResponseWriter, r *http.Request) {

	// Step 1: Make a GET request to the remote API

	vars := mux.Vars(r)

	id := vars["id"]

	remoteURL := "https://leadbook.ru/test-task-api/events/" + id + "/places"

	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, remoteURL, nil)

	if err != nil {

		return

	}

	resp, err := http.DefaultClient.Do(req)

	if err != nil {

		return

	}

	defer resp.Body.Close()

	// Step 2: Decode the response

	body, err := io.ReadAll(resp.Body)

	if err != nil {

		return

	}

	var placeListResponse model.PlaceListResponse

	if err := json.Unmarshal(body, &placeListResponse); err != nil {

		return

	}

	// Step 3: Iterate over places and store them in the local service

	for _, place := range placeListResponse.Response {

		if err := placeListResponse.PlaceListResponseValidate(); err != nil {

			return

		}

		_, err := s.app.CreatePlace(r.Context(), models.Place{

			ID:          place.ID,

			X:           place.X,

			Y:           place.Y,

			Width:       place.Width,

			Height:      place.Height,

			IsAvailable: place.IsAvailable,

		})

		if err != nil {

			return

		}

	}

	srv.RespondOK(placeListResponse.Response, w, r)

}

// @title Ticket API

// @version 1

// @description API Server for remote Tickets Application.

func (s *Server) Start(ctx context.Context) error {

	addr := net.JoinHostPort(s.host, s.port)

	midLogger := NewMiddlewareLogger()

	router := mux.NewRouter()

	router.Handle("/healthz", midLogger.setCommonHeadersMiddleware(

		midLogger.loggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

			w.WriteHeader(http.StatusOK)

			w.Write([]byte("OK healthz\n"))

		}))))

	router.Handle("/readiness", midLogger.setCommonHeadersMiddleware(

		midLogger.loggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

			w.WriteHeader(http.StatusOK)

			w.Write([]byte("OK readiness\n"))

		}))))

	router.PathPrefix("/swagger/").Handler(httpSwagger.WrapHandler)

	router.Handle("/shows", midLogger.setCommonHeadersMiddleware(

		midLogger.loggingMiddleware(http.HandlerFunc(s.GetShows))))

	router.Handle("/shows/{id:[0-9]+}/events", midLogger.setCommonHeadersMiddleware(

		midLogger.loggingMiddleware(http.HandlerFunc(s.GetEvents))))

	router.Handle("/events/{id:[0-9]+}/places", midLogger.setCommonHeadersMiddleware(

		midLogger.loggingMiddleware(http.HandlerFunc(s.GetPlaces))))

	s.srv = http.Server{

		Addr:              addr,

		Handler:           router,

		ReadHeaderTimeout: 2 * time.Second,

		BaseContext: func(_ net.Listener) context.Context {

			bCtx := context.WithValue(ctx, KeyLoggerID, s.log)

			return bCtx

		},

	}

	s.log.Infof("http server started on %s:%s\n", s.host, s.port)

	return s.srv.ListenAndServe()

}

func (s *Server) Stop(ctx context.Context) error {

	if err := s.srv.Shutdown(ctx); err != nil {

		return err

	}

	s.log.Infof("http server shutdown\n")

	return nil

}