package cmd

import (
	"encoding/json"
	"fmt"
	"git.db.org.ai/dborg/internal/client"
	"git.db.org.ai/dborg/internal/config"
	"git.db.org.ai/dborg/internal/models"
	"git.db.org.ai/dborg/internal/utils"

	"github.com/spf13/cobra"
)

var osintCmd = &cobra.Command{
	Use:   "osint",
	Short: "OSINT tools and searches",
	Long:  `Open Source Intelligence tools for username, email, and other searches`,
}

var osintUsernameCmd = &cobra.Command{
	Use:   "username [username]",
	Short: "Check username availability across websites",
	Long:  `Check username availability across hundreds of websites using WhatsMyName dataset`,
	Args:  cobra.ExactArgs(1),
	RunE:  runOsintUsernameCheck,
}

var osintBSSIDCmd = &cobra.Command{
	Use:   "bssid [bssid]",
	Short: "Lookup WiFi access point location by BSSID",
	Long:  `Lookup geographic location of a WiFi access point by its BSSID (MAC address) using Apple's location services`,
	Args:  cobra.ExactArgs(1),
	RunE:  runOsintBSSIDLookup,
}

var osintBreachForumCmd = &cobra.Command{
	Use:   "breachforum [search]",
	Short: "Search BreachForum data",
	Long:  `Search breachdetect index for BreachForum messages and detections`,
	Args:  cobra.ExactArgs(1),
	RunE:  runOsintBreachForumSearch,
}

var osintFilesCmd = &cobra.Command{
	Use:   "files [url]",
	Short: "Search open directory files",
	Long:  `Search for files in open directories using various filters (free OSINT endpoint)`,
	Args:  cobra.ExactArgs(1),
	RunE:  runOsintFilesSearch,
}

var osintBucketsCmd = &cobra.Command{
	Use:   "buckets",
	Short: "List public buckets",
	Long:  `List public S3, Azure, GCP, and DigitalOcean buckets with file counts`,
	RunE:  runOsintBucketsSearch,
}

var osintBucketFilesCmd = &cobra.Command{
	Use:   "bucket-files",
	Short: "Search public bucket files",
	Long:  `Search public S3, Azure, GCP, and DigitalOcean buckets for exposed files`,
	RunE:  runOsintBucketFilesSearch,
}

var osintShortlinksCmd = &cobra.Command{
	Use:   "shortlinks",
	Short: "Search brute forced short links",
	Long:  `Search for exposed URLs discovered through brute forcing URL shortener services`,
	RunE:  runOsintShortlinksSearch,
}

var osintGeoCmd = &cobra.Command{
	Use:   "geo",
	Short: "Search for address information",
	Long:  `Returns address information including residents, property details, and demographics (costs 1 credit)`,
	RunE:  runOsintGeoSearch,
}

func init() {
	rootCmd.AddCommand(osintCmd)
	osintCmd.AddCommand(osintUsernameCmd)
	osintCmd.AddCommand(osintBSSIDCmd)
	osintCmd.AddCommand(osintBreachForumCmd)
	osintCmd.AddCommand(osintFilesCmd)
	osintCmd.AddCommand(osintBucketsCmd)
	osintCmd.AddCommand(osintBucketFilesCmd)
	osintCmd.AddCommand(osintShortlinksCmd)
	osintCmd.AddCommand(osintGeoCmd)

	osintUsernameCmd.Flags().StringSliceP("sites", "s", []string{}, "Specific sites to check (comma-separated)")
	osintUsernameCmd.Flags().BoolP("fuzzy", "f", false, "Enable fuzzy validation mode")
	osintUsernameCmd.Flags().IntP("max_tasks", "m", 50, "Maximum concurrent tasks")

	osintBSSIDCmd.Flags().BoolP("all", "a", false, "Show all related results instead of exact match only")
	osintBSSIDCmd.Flags().BoolP("google", "g", false, "Include Google Maps URL for the location")
	osintBSSIDCmd.Flags().BoolP("osm", "o", false, "Include OpenStreetMap URL for the location")

	osintBreachForumCmd.Flags().IntP("max_hits", "m", 10, "Maximum number of hits to return")

	osintFilesCmd.Flags().StringP("filename", "n", "", "Search term to match in filenames")
	osintFilesCmd.Flags().StringP("extension", "e", "", "Filter by file extension(s) - comma-separated (e.g., pdf,doc,txt)")
	osintFilesCmd.Flags().StringP("exclude", "x", "html,HTML", "Exclude file extension(s) - comma-separated")
	osintFilesCmd.Flags().IntP("size", "s", 10, "Number of results to return (max 40)")
	osintFilesCmd.Flags().IntP("from", "f", 0, "Starting offset for pagination")

	osintBucketsCmd.Flags().IntP("limit", "l", 1000, "Number of results to return")
	osintBucketsCmd.Flags().IntP("start", "t", 0, "Starting offset for pagination")

	osintBucketFilesCmd.Flags().StringP("keywords", "w", "", "Search keywords")
	osintBucketFilesCmd.Flags().StringP("extensions", "e", "", "File extensions (comma-separated, e.g. 'sql,db,xlsx')")
	osintBucketFilesCmd.Flags().StringP("buckets", "b", "", "Filter by bucket names (comma-separated)")
	osintBucketFilesCmd.Flags().IntP("limit", "l", 1000, "Number of results to return")
	osintBucketFilesCmd.Flags().IntP("start", "t", 0, "Starting offset for pagination")

	osintShortlinksCmd.Flags().StringP("keywords", "w", "", "Search keywords")
	osintShortlinksCmd.Flags().StringP("ext", "e", "", "File extensions (comma-separated, e.g. 'pdf,docx,xlsx')")
	osintShortlinksCmd.Flags().StringP("order", "o", "", "Sort by property (size, timestamp)")
	osintShortlinksCmd.Flags().StringP("direction", "d", "", "Sort direction (asc, desc)")
	osintShortlinksCmd.Flags().BoolP("regexp", "r", false, "Treat keywords as regular expression")
	osintShortlinksCmd.Flags().IntP("limit", "l", 100, "Number of results to return")
	osintShortlinksCmd.Flags().IntP("start", "t", 0, "Starting offset for pagination")

	osintGeoCmd.Flags().StringP("street", "s", "", "Street address")
	osintGeoCmd.Flags().StringP("city", "c", "", "City")
	osintGeoCmd.Flags().StringP("state", "t", "", "State (2-letter code)")
	osintGeoCmd.Flags().StringP("zip", "z", "", "ZIP code")
	osintGeoCmd.MarkFlagRequired("street")
	osintGeoCmd.MarkFlagRequired("city")
	osintGeoCmd.MarkFlagRequired("state")
	osintGeoCmd.MarkFlagRequired("zip")
}

func runOsintUsernameCheck(cmd *cobra.Command, args []string) error {
	cfg := config.New()

	c, err := client.NewUnauthenticated(cfg)
	if err != nil {
		return err
	}

	params := &models.USRSXParams{
		Username: args[0],
	}
	params.Sites, _ = cmd.Flags().GetStringSlice("sites")
	params.Fuzzy, _ = cmd.Flags().GetBool("fuzzy")
	params.MaxTasks, _ = cmd.Flags().GetInt("max_tasks")

	err = c.CheckUsernameStream(params, func(result json.RawMessage) error {
		fmt.Println(string(result))
		return nil
	})

	if err != nil {
		return err
	}

	return nil
}

func runOsintBSSIDLookup(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.BSSIDParams{
		BSSID: args[0],
	}
	params.All, _ = cmd.Flags().GetBool("all")
	params.Google, _ = cmd.Flags().GetBool("google")
	params.OSM, _ = cmd.Flags().GetBool("osm")

	response, err := c.LookupBSSID(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintBreachForumSearch(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.BreachForumSearchParams{
		Search: args[0],
	}
	params.MaxHits, _ = cmd.Flags().GetInt("max_hits")

	response, err := c.SearchBreachForum(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintFilesSearch(cmd *cobra.Command, args []string) error {
	cfg := config.New()

	c, err := client.NewUnauthenticated(cfg)
	if err != nil {
		return err
	}

	params := &models.OpenDirectorySearchParams{
		URL: args[0],
	}
	params.Filename, _ = cmd.Flags().GetString("filename")
	params.Extension, _ = cmd.Flags().GetString("extension")
	params.Exclude, _ = cmd.Flags().GetString("exclude")
	params.Size, _ = cmd.Flags().GetInt("size")
	params.From, _ = cmd.Flags().GetInt("from")

	response, err := c.SearchOpenDirectoryFiles(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintBucketsSearch(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.BucketsSearchParams{}
	params.Limit, _ = cmd.Flags().GetInt("limit")
	params.Start, _ = cmd.Flags().GetInt("start")

	response, err := c.SearchBuckets(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintBucketFilesSearch(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.BucketsFilesSearchParams{}
	params.Keywords, _ = cmd.Flags().GetString("keywords")
	params.Extensions, _ = cmd.Flags().GetString("extensions")
	params.Buckets, _ = cmd.Flags().GetString("buckets")
	params.Limit, _ = cmd.Flags().GetInt("limit")
	params.Start, _ = cmd.Flags().GetInt("start")

	response, err := c.SearchBucketFiles(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintShortlinksSearch(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.ShortlinksSearchParams{}
	params.Keywords, _ = cmd.Flags().GetString("keywords")
	params.Ext, _ = cmd.Flags().GetString("ext")
	params.Order, _ = cmd.Flags().GetString("order")
	params.Direction, _ = cmd.Flags().GetString("direction")
	params.Regexp, _ = cmd.Flags().GetBool("regexp")
	params.Limit, _ = cmd.Flags().GetInt("limit")
	params.Start, _ = cmd.Flags().GetInt("start")

	response, err := c.SearchShortlinks(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}

func runOsintGeoSearch(cmd *cobra.Command, args []string) error {
	apiKey, _ := cmd.Flags().GetString("api-key")
	cfg := config.New().WithAPIKey(apiKey)

	c, err := client.New(cfg)
	if err != nil {
		return err
	}

	params := &models.GeoSearchParams{}
	params.Street, _ = cmd.Flags().GetString("street")
	params.City, _ = cmd.Flags().GetString("city")
	params.State, _ = cmd.Flags().GetString("state")
	params.Zip, _ = cmd.Flags().GetString("zip")

	response, err := c.SearchGeo(params)
	if err != nil {
		return err
	}

	return utils.PrintJSON(response)
}