package client

import (
	"encoding/json"
	"fmt"
	"git.db.org.ai/dborg/internal/models"
	"strings"
)

func (c *Client) GetBundleDetection(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/bundle-detection/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetCrossTraders(addresses string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/cross-traders/%s", addresses)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetEarlyAdopters(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/early-adopters/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetFloorHolders(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/floor-holders/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetFreshAccounts(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/fresh-accounts/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetFundingSource(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/funding-source/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetGraduationStats() (*models.CryptoResponse, error) {
	data, err := c.Get("/crypto/graduation-stats", nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetLaunchParticipants(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/launch-participants/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetLiquidity(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/liquidity/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetOwnerIntel(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/owner-intel/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetOwnershipDistribution(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/ownership-distribution/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetPortfolio(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/portfolio/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetTopOwners(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/top-owners/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func (c *Client) GetWhaleIntel(address string) (*models.CryptoResponse, error) {
	path := fmt.Sprintf("/crypto/whale-intel/%s", address)
	data, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var response models.CryptoResponse
	if err := json.Unmarshal(data, &response); err != nil {
		return nil, fmt.Errorf("failed to parse crypto response: %w", err)
	}

	return &response, nil
}

func ValidateCryptoAddress(address string) error {
	if len(address) == 0 {
		return fmt.Errorf("address cannot be empty")
	}
	return nil
}

func ValidateCryptoAddresses(addresses string) error {
	if len(addresses) == 0 {
		return fmt.Errorf("addresses cannot be empty")
	}
	parts := strings.Split(addresses, ",")
	if len(parts) < 2 {
		return fmt.Errorf("at least 2 addresses required for cross-trader analysis")
	}
	return nil
}