package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"sync"
	"syscall"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
	"github.com/jessevdk/go-flags"
)

type Options struct {
	ConfigFile string `short:"c" long:"config" description:"Config file name" required:"true"`
}

func main() {
	var (
		opt Options
		cfg Config
		wg  sync.WaitGroup
	)

	_, err := flags.ParseArgs(&opt, os.Args)
	if err != nil {
		os.Exit(1)
	}

	err = readConfig(opt.ConfigFile, &cfg)
	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "Failed to run: [%s]\n", err.Error())
		os.Exit(2)
	}

	bot, err := tgbotapi.NewBotAPI(cfg.BotToken)
	if err != nil {
		log.Panic(err)
	}

	db, err := connectToDataBase(
		cfg.Postgres.Host,
		cfg.Postgres.Port,
		cfg.Postgres.User,
		cfg.Postgres.Password,
		cfg.Postgres.DBName,
	)

	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "Failed to connect db: [%s]\n", err.Error())
		os.Exit(5)
	}

	ch := newCommandHandler()
	pb := newPlayersBoard()
	ms := NewMessageStorage()

	ctx, cancelFunc := createContext(&cfg, bot, ch, db, pb, ms)

	getLogger(ctx).Infof("Run...")

	err = pb.load(ctx)
	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "Failed to show players board: [%s]\n", err.Error())
		os.Exit(5)
	}

	runCommandHandler(ctx, ch, &wg)
	runMessageStorage(ctx, ms, &wg)
	runHttpServer(ctx, cfg.Http, &wg)
	runSignalHandler(ctx, cancelFunc)

	getLogger(ctx).Infof("Running")

	wg.Wait()
}

func runCommandHandler(ctx context.Context, ch *commandHandler, wg *sync.WaitGroup) {
	wg.Add(1)

	go func() {
		defer wg.Done()

		ch.run(ctx)
	}()
}

func runMessageStorage(ctx context.Context, ms *messageStorage, wg *sync.WaitGroup) {
	wg.Add(1)

	go func() {
		defer wg.Done()

		ms.run(ctx)
	}()
}

func runHttpServer(ctx context.Context, addr string, wg *sync.WaitGroup) {
	server := http.Server{
		Addr:    addr,
		Handler: newHttpHandler(ctx),
	}

	getLogger(ctx).Infof("Run http server on: [%s]", addr)

	ls, err := (&net.ListenConfig{}).Listen(ctx, "tcp", addr)
	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "Failed open port: [%s]\n", err.Error())
		os.Exit(3)
	}

	go func() {
		<-ctx.Done()
		_ = server.Close()
	}()

	wg.Add(1)

	go func() {
		defer wg.Done()

		err = server.Serve(ls)
		if err != nil && err != http.ErrServerClosed {
			_, _ = fmt.Fprintf(os.Stderr, "Failed to run http server: [%s]\n", err.Error())
			os.Exit(4)
		}
	}()
}

func runSignalHandler(ctx context.Context, cancelFunc func()) {
	sigs := make(chan os.Signal, 1)

	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		for {
			switch <-sigs {
			case syscall.SIGINT, syscall.SIGTERM:
				getLogger(ctx).Infof("Interrapt, exit.")
				cancelFunc()
			}
		}
	}()
}

// =====
//mess := tgbotapi.NewMessage(-1001155171053, "")
//m, err := bot.Send(mess)

//var updateID int
//
//for {
//	updates, _ := bot.GetUpdates(tgbotapi.UpdateConfig{
//		Offset:  updateID + 1,
//		Timeout: 30,
//	})
//
//	for _, u := range updates {
//		updateID = u.UpdateID
//
//		fmt.Println(u.Message.Chat.ID, u.Message.Text)
//
//		mess := tgbotapi.NewMessage(51716267, u.Message.Text)
//		bot.Send(mess)
//	}
//
//	fmt.Println("qq")
//}

// =====