package main

import (
	"bytes"
	"context"
	"encoding/hex"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"log/slog"
	"net"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"time"

	"github.com/disgoorg/disgo"
	"github.com/disgoorg/disgo/bot"
	"github.com/disgoorg/disgo/discord"
	"github.com/disgoorg/disgo/handler"
	"github.com/disgoorg/disgo/handler/middleware"
	"github.com/disgoorg/disgo/httpserver"
	"github.com/disgoorg/disgo/rest"
	httpmiddle "github.com/go-chi/chi/v5/middleware"
	"zombiezen.com/go/sqlite"
	"zombiezen.com/go/sqlite/sqlitex"

	"git.sunturtle.xyz/zephyr/horse"
	"git.sunturtle.xyz/zephyr/horse/mdb"
)

func main() {
	var (
		// public site
		addr   string
		mdbf   string
		public string
		// discord
		tokenFile string
		apiRoute  string
		pubkey    string
		// logging
		level   slog.Level
		textfmt string
	)
	flag.StringVar(&addr, "http", ":80", "`address` to bind HTTP server")
	flag.StringVar(&mdbf, "mdb", "", "`path` to master.mdb")
	flag.StringVar(&public, "public", "", "`dir`ectory containing the website to serve")
	flag.StringVar(&tokenFile, "token", "", "`file` containing the Discord bot token")
	flag.StringVar(&apiRoute, "route", "/interactions/callback", "`path` to serve Discord HTTP API calls")
	flag.StringVar(&pubkey, "key", "", "Discord public key")
	flag.TextVar(&level, "log", slog.LevelInfo, "slog logging `level`")
	flag.StringVar(&textfmt, "log-format", "text", "slog logging `format`, text or json")
	flag.Parse()

	var lh slog.Handler
	switch textfmt {
	case "text":
		lh = slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: level})
	case "json":
		lh = slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: level})
	default:
		fmt.Fprintf(os.Stderr, "invalid log format %q, must be text or json", textfmt)
		os.Exit(1)
	}
	slog.SetDefault(slog.New(lh))

	stat, err := os.Stat(public)
	if err != nil {
		slog.Error("public", slog.Any("err", err))
		os.Exit(1)
	}
	if !stat.IsDir() {
		slog.Error("public", slog.String("err", "not a directory"))
		os.Exit(1)
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)

	db, err := sqlitex.NewPool(mdbf, sqlitex.PoolOptions{Flags: sqlite.OpenReadOnly})
	if err != nil {
		slog.Error("mdb", slog.Any("err", err))
		os.Exit(1)
	}

	skills, err := mdb.Skills(ctx, db)
	slog.Info("loaded skills", slog.Int("count", len(skills)))
	groups, err2 := mdb.SkillGroups(ctx, db)
	slog.Info("loaded skill groups", slog.Int("count", len(groups)))
	if err = errors.Join(err, err2); err != nil {
		slog.Error("loading data", slog.Any("err", err))
		os.Exit(1)
	}
	skillSrv := newSkillServer(skills, groups)
	slog.Info("skill server ready")

	token, err := os.ReadFile(tokenFile)
	if err != nil {
		slog.Error("reading token", slog.Any("err", err))
		os.Exit(1)
	}
	token = bytes.TrimSuffix(token, []byte{'\n'})

	r := handler.New()
	r.DefaultContext(func() context.Context { return ctx })
	r.Use(middleware.Go)
	r.Use(logMiddleware)
	r.Route("/skill", func(r handler.Router) {
		r.SlashCommand("/", skillSrv.slash)
		r.Autocomplete("/", skillSrv.autocomplete)
		r.SelectMenuComponent("/swap", skillSrv.menu)
		r.ButtonComponent("/swap/{id}", skillSrv.button)
	})
	slog.Info("connect", slog.String("disgo", disgo.Version))
	client, err := disgo.New(string(token), bot.WithDefaultGateway(), bot.WithEventListeners(r))
	if err != nil {
		slog.Error("building bot", slog.Any("err", err))
		os.Exit(1)
	}

	mux := http.NewServeMux()
	mux.Handle("GET /", httpmiddle.Compress(5)(http.FileServerFS(os.DirFS(public))))
	mux.Handle("GET /api/data/affinity", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.AffinitySummary)))
	mux.Handle("GET /api/data/character", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Characters)))
	mux.Handle("GET /api/data/conversation", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Conversations)))
	mux.Handle("GET /api/data/race", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Races)))
	mux.Handle("GET /api/data/saddle", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Saddles)))
	mux.Handle("GET /api/data/scenario", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Scenarios)))
	mux.Handle("GET /api/data/skill", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Skills)))
	mux.Handle("GET /api/data/skill-group", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.SkillGroups)))
	mux.Handle("GET /api/data/spark", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Sparks)))
	mux.Handle("GET /api/data/uma", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Umas)))
	if pubkey != "" {
		pk, err := hex.DecodeString(pubkey)
		if err != nil {
			slog.Error("pubkey", slog.Any("err", err))
			os.Exit(1)
		}
		mux.Handle("POST "+apiRoute, httpserver.HandleInteraction(httpserver.DefaultVerifier{}, pk, slog.Default(), client.EventManager.HandleHTTPEvent))
		slog.Info("Discord HTTP API enabled", slog.String("pubkey", pubkey))
	}
	l, err := net.Listen("tcp", addr)
	if err != nil {
		slog.Error("listen", slog.String("addr", addr), slog.Any("err", err))
		os.Exit(1)
	}
	srv := http.Server{
		Addr:         addr,
		Handler:      mux,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
		BaseContext:  func(l net.Listener) context.Context { return ctx },
	}
	go func() {
		slog.Info("HTTP", slog.Any("addr", l.Addr()))
		err := srv.Serve(l)
		if err == http.ErrServerClosed {
			return
		}
		slog.Error("HTTP server closed", slog.Any("err", err))
	}()

	if err := handler.SyncCommands(client, commands, nil, rest.WithCtx(ctx)); err != nil {
		slog.Error("syncing commands", slog.Any("err", err))
		os.Exit(1)
	}

	slog.Info("start gateway")
	if err := client.OpenGateway(ctx); err != nil {
		slog.Error("starting gateway", slog.Any("err", err))
		stop()
	}
	slog.Info("ready")
	<-ctx.Done()
	stop()

	ctx, stop = context.WithTimeout(context.Background(), 5*time.Second)
	defer stop()
	client.Close(ctx)
	if err := srv.Shutdown(ctx); err != nil {
		slog.Error("HTTP API shutdown", slog.Any("err", err))
		os.Exit(1)
	}
}

var commands = []discord.ApplicationCommandCreate{
	discord.SlashCommandCreate{
		Name:        "skill",
		Description: "Umamusume skill data",
		Options: []discord.ApplicationCommandOption{
			discord.ApplicationCommandOptionString{
				Name:         "query",
				Description:  "Skill name or ID",
				Required:     true,
				Autocomplete: true,
			},
			discord.ApplicationCommandOptionBool{
				Name:        "share",
				Description: "Share the skill info",
			},
		},
	},
}

func loadSkills(file string) ([]horse.Skill, error) {
	b, err := os.ReadFile(file)
	if err != nil {
		return nil, err
	}
	var skills []horse.Skill
	if err := json.Unmarshal(b, &skills); err != nil {
		return nil, err
	}
	return skills, nil
}

func loadSkillGroups(file string) ([]horse.SkillGroup, error) {
	b, err := os.ReadFile(file)
	if err != nil {
		return nil, err
	}
	var groups []horse.SkillGroup
	if err := json.Unmarshal(b, &groups); err != nil {
		return nil, err
	}
	return groups, nil
}

func dataroute[T any](ctx context.Context, db *sqlitex.Pool, f func(context.Context, *sqlitex.Pool) ([]T, error)) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		data, err := f(ctx, db)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		b, err := json.Marshal(data)
		if err != nil {
			panic(err)
		}
		w.Header().Set("Content-Type", "application/json")
		w.Header().Set("Content-Length", strconv.Itoa(len(b)))
		if _, err := w.Write(b); err != nil {
			slog.Error("writing response", slog.Any("err", err))
			return
		}
	}
}