package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"syscall"

	"github.com/urfave/cli/v2"
	"github.com/your-username/mev-beta/internal/config"
	"github.com/your-username/mev-beta/internal/logger"
	"github.com/your-username/mev-beta/internal/ratelimit"
	"github.com/your-username/mev-beta/pkg/market"
	"github.com/your-username/mev-beta/pkg/monitor"
	"github.com/your-username/mev-beta/pkg/scanner"
)

func main() {
	app := &cli.App{
		Name:  "mev-bot",
		Usage: "An MEV bot that monitors Arbitrum sequencer for swap opportunities",
		Commands: []*cli.Command{
			{
				Name:  "start",
				Usage: "Start the MEV bot",
				Action: func(c *cli.Context) error {
					return startBot()
				},
			},
			{
				Name:  "scan",
				Usage: "Scan for potential arbitrage opportunities",
				Action: func(c *cli.Context) error {
					fmt.Println("Scanning for arbitrage opportunities...")
					// TODO: Implement scanning logic
					return nil
				},
			},
		},
	}

	if err := app.Run(os.Args); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
}

func startBot() error {
	// Load configuration
	cfg, err := config.Load("config/config.yaml")
	if err != nil {
		return fmt.Errorf("failed to load config: %w", err)
	}

	// Initialize logger
	log := logger.New(cfg.Log.Level, cfg.Log.Format, cfg.Log.File)

	log.Info("Starting MEV bot...")

	// Create rate limiter manager
	rateLimiter := ratelimit.NewLimiterManager(&cfg.Arbitrum)

	// Create market manager
	marketMgr := market.NewMarketManager(&cfg.Uniswap, log)

	// Create market scanner
	scanner := scanner.NewMarketScanner(&cfg.Bot, log)

	// Create Arbitrum monitor with concurrency support
	monitor, err := monitor.NewArbitrumMonitor(
		&cfg.Arbitrum,
		&cfg.Bot,
		log,
		rateLimiter,
		marketMgr,
		scanner,
	)
	if err != nil {
		return fmt.Errorf("failed to create Arbitrum monitor: %w", err)
	}

	// Set up context with cancellation
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// Set up signal handling for graceful shutdown
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	// Start monitoring in a goroutine
	go func() {
		if err := monitor.Start(ctx); err != nil {
			log.Error("Monitor error: ", err)
		}
	}()

	log.Info("MEV bot started. Press Ctrl+C to stop.")

	// Wait for signal
	<-sigChan
	log.Info("Received shutdown signal...")

	// Cancel context to stop monitor
	cancel()

	// Stop the monitor
	monitor.Stop()

	// Stop the scanner
	scanner.Stop()

	log.Info("MEV bot stopped.")
	return nil
}