package fetch

import (
	"encoding/json"
	"fmt"
	"log/slog"
	"slices"
	"time"

	"git.avsdev.uk/Go/job-search/internal/cli"
	"git.avsdev.uk/Go/job-search/internal/findATender"
	"git.avsdev.uk/Go/job-search/internal/findATender/ocds"
	"github.com/spf13/cobra"
)

func filter(reqs []ocds.Release, tag string) []ocds.Release {
	var resp []ocds.Release
	for _, req := range reqs {
		if slices.Contains(req.Tag, tag) {
			resp = append(resp, req)
		}
	}
	return resp
}

func commandOnce(opts *cli.Options) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "once",
		Short: "Fetch current opportunities - single shot",
		PersistentPreRun: func(cmd *cobra.Command, args []string) {
			slog.Debug("fetch.once.PersistentPreRun")
		},
		PersistentPostRun: func(cmd *cobra.Command, args []string) {
			slog.Debug("fetch.once.PersistentPostRun")
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			slog.Debug("fetch.once.Run")

			conf, err := opts.RunSetup(cmd, true, true)
			if err != nil {
				return fmt.Errorf("no configuration loaded (%w)", err)
			}

			since, sinceErr := cmd.Flags().GetTime("since")
			if sinceErr != nil {
				return sinceErr
			}

			ft := findATender.New(conf, conf.Sources.FindATender.APIRoot)
			defer ft.Shutdown()

			ignoreRateLimit, _ := cmd.Flags().GetBool("ignore-rate-limit")

			results, err := ft.FetchAll(since, !ignoreRateLimit)
			if err != nil {
				return err
			}

			planning, _ := cmd.Flags().GetBool("planning")
			opportunities, _ := cmd.Flags().GetBool("opportunities")
			awards, _ := cmd.Flags().GetBool("awards")

			if (planning && (opportunities || awards)) ||
				(opportunities && (planning || awards)) ||
				(awards && (planning || opportunities)) {
				return fmt.Errorf(
					"--planning, --opportunities and --awards are exclusive, only one can be provided",
				)
			}

			filterTag := ""
			if planning {
				filterTag = "planning"
			}
			if opportunities {
				filterTag = "opportunity"
			}
			if awards {
				filterTag = "award"
			}

			if len(filterTag) > 0 {
				results = filter(results, filterTag)
			}

			jbytes, err := json.MarshalIndent(results, "", "  ")
			if err != nil {
				return err
			}
			fmt.Println(string(jbytes))

			return nil
		},
	}
	cmd.Flags().Time(
		"since",
		time.Time{},
		[]string{
			time.DateOnly, time.DateTime,
		},
		"contract updates published since YYYY-MM-DD[ hh:mm:ss]",
	)
	cmd.Flags().Bool(
		"planning", false, "only return planning (i.e. exclude opportunities and awards)",
	)
	cmd.Flags().Bool(
		"opportunities", false, "only return opportunities (i.e. exclude awards and planning)",
	)
	cmd.Flags().Bool(
		"awards", false, "only return awards (i.e. exclude planning and opportunities)",
	)
	cmd.Flags().Bool(
		"ignore-rate-limit", false, "ignore the rate limit and fail if exceeded",
	)
	return cmd
}