validation.go

package threads

import (
	"fmt"
	"regexp"
	"strings"
	"unicode/utf8"
)

// Validator provides common validation methods
type Validator struct{}

// NewValidator creates a new validator instance
func NewValidator() *Validator {
	return &Validator{}
}

// ValidatePostContent performs common validation for all post types
func (v *Validator) ValidatePostContent(content interface{}, _ int) error {
	if content == nil {
		return NewValidationError(400, "Content cannot be nil", "Post content is required", "content")
	}
	return nil
}

// ValidateTextLength validates text doesn't exceed maximum length.
// The Threads API limits text posts to 500 characters (Unicode code points),
// not 500 bytes. Using utf8.RuneCountInString ensures CJK and other
// multi-byte characters are correctly counted as 1 character each.
func (v *Validator) ValidateTextLength(text string, fieldName string) error {
	if utf8.RuneCountInString(text) > MaxTextLength {
		return NewValidationError(400,
			fmt.Sprintf("%s too long", fieldName),
			fmt.Sprintf("%s is limited to %d characters", fieldName, MaxTextLength),
			strings.ToLower(fieldName))
	}
	return nil
}

// ValidateLinkCount validates that the text does not contain more than the allowed number of links
func (v *Validator) ValidateLinkCount(text string, linkAttachmentURL string) error {
	// Map to track unique URLs
	uniqueURLs := make(map[string]bool)

	// Helper to normalize URLs for uniqueness check
	// This is a simple normalization (trim spaces/slashes).
	normalize := func(u string) string {
		u = strings.TrimSpace(u)
		return strings.TrimRight(u, "/")
	}

	// 1. Extract URLs from text
	// This regex captures http:// or https:// followed by non-whitespace characters
	if text != "" {
		re := regexp.MustCompile(`https?://[^\s]+`)
		matches := re.FindAllString(text, -1)
		for _, match := range matches {
			uniqueURLs[normalize(match)] = true
		}
	}

	// 2. Add link_attachment if present
	if linkAttachmentURL != "" {
		uniqueURLs[normalize(linkAttachmentURL)] = true
	}

	// 3. Check count
	if len(uniqueURLs) > MaxLinks {
		return NewValidationError(400,
			"Too many links",
			fmt.Sprintf("Post cannot contain more than %d unique links (found %d)", MaxLinks, len(uniqueURLs)),
			"text")
	}

	return nil
}

// ValidateTextAttachment validates text attachment structure and content
func (v *Validator) ValidateTextAttachment(textAttachment *TextAttachment) error {
	if textAttachment == nil {
		return nil // Text attachment is optional
	}

	// Validate plaintext length (required field, max 10K chars)
	if textAttachment.Plaintext == "" {
		return NewValidationError(400,
			"Text attachment plaintext required",
			"Text attachment must have a plaintext field",
			"text_attachment.plaintext")
	}

	if utf8.RuneCountInString(textAttachment.Plaintext) > MaxTextAttachmentLength {
		return NewValidationError(400,
			"Text attachment plaintext too long",
			fmt.Sprintf("Text attachment plaintext is limited to %d characters (currently %d)", MaxTextAttachmentLength, utf8.RuneCountInString(textAttachment.Plaintext)),
			"text_attachment.plaintext")
	}

	// Validate text styling ranges don't overlap
	if len(textAttachment.TextWithStylingInfo) > 0 {
		if err := v.validateTextStylingRanges(textAttachment.TextWithStylingInfo); err != nil {
			return err
		}
	}

	return nil
}

// validateTextStylingRanges checks that text styling ranges don't overlap and that
// each styling entry contains only valid style values.
func (v *Validator) validateTextStylingRanges(stylingInfo []TextStylingInfo) error {
	validStyles := map[string]bool{
		"bold":          true,
		"italic":        true,
		"highlight":     true,
		"underline":     true,
		"strikethrough": true,
	}

	for i := 0; i < len(stylingInfo); i++ {
		// Validate style values
		for _, style := range stylingInfo[i].StylingInfo {
			if !validStyles[style] {
				return NewValidationError(400,
					"Invalid text styling value",
					fmt.Sprintf("Text styling range %d contains invalid style '%s'. Valid styles are: bold, italic, highlight, underline, strikethrough", i, style),
					"text_attachment.text_with_styling_info")
			}
		}

		for j := i + 1; j < len(stylingInfo); j++ {
			// Check if ranges overlap
			start1, end1 := stylingInfo[i].Offset, stylingInfo[i].Offset+stylingInfo[i].Length
			start2, end2 := stylingInfo[j].Offset, stylingInfo[j].Offset+stylingInfo[j].Length

			if start1 < end2 && end1 > start2 {
				return NewValidationError(400,
					"Overlapping text styling ranges",
					fmt.Sprintf("Text styling ranges cannot overlap: range %d [%d,%d) overlaps with range %d [%d,%d)",
						i, start1, end1, j, start2, end2),
					"text_attachment.text_with_styling_info")
			}
		}
	}
	return nil
}

// ValidatePollAttachment validates poll attachment options.
// The API requires MinPollOptions (2) to MaxPollOptions (4) options.
// Options A and B are required; options C and D are optional.
// Each provided option must be 1-MaxPollOptionLength (25) characters.
func (v *Validator) ValidatePollAttachment(poll *PollAttachment) error {
	if poll == nil {
		return nil // Poll attachment is optional
	}

	// Options A and B are required (MinPollOptions = 2)
	if poll.OptionA == "" {
		return NewValidationError(400,
			"Poll option A required",
			fmt.Sprintf("Poll attachment must have at least %d options (option_a is required)", MinPollOptions),
			"poll_attachment.option_a")
	}
	if poll.OptionB == "" {
		return NewValidationError(400,
			"Poll option B required",
			fmt.Sprintf("Poll attachment must have at least %d options (option_b is required)", MinPollOptions),
			"poll_attachment.option_b")
	}

	// Options must be sequential: D requires C
	if poll.OptionD != "" && poll.OptionC == "" {
		return NewValidationError(400,
			"Poll option C required before D",
			"Cannot set option_d without option_c",
			"poll_attachment.option_c")
	}

	// Validate length of each provided option
	options := []struct {
		value string
		field string
	}{
		{poll.OptionA, "poll_attachment.option_a"},
		{poll.OptionB, "poll_attachment.option_b"},
		{poll.OptionC, "poll_attachment.option_c"},
		{poll.OptionD, "poll_attachment.option_d"},
	}

	for _, opt := range options {
		if opt.value == "" {
			continue // optional options can be empty
		}
		if strings.TrimSpace(opt.value) == "" {
			return NewValidationError(400,
				"Poll option cannot be blank",
				fmt.Sprintf("Poll option in %s must contain non-whitespace characters", opt.field),
				opt.field)
		}
		if utf8.RuneCountInString(opt.value) > MaxPollOptionLength {
			return NewValidationError(400,
				"Poll option too long",
				fmt.Sprintf("Poll option in %s must be at most %d characters", opt.field, MaxPollOptionLength),
				opt.field)
		}
	}

	return nil
}

// ValidateAltText validates alt text for media posts.
// Alt text is optional but cannot exceed MaxAltTextLength characters.
func (v *Validator) ValidateAltText(altText string) error {
	if altText == "" {
		return nil // Alt text is optional
	}
	if utf8.RuneCountInString(altText) > MaxAltTextLength {
		return NewValidationError(400,
			"Alt text too long",
			fmt.Sprintf("Alt text is limited to %d characters", MaxAltTextLength),
			"alt_text")
	}
	return nil
}

// ValidateTextEntities validates text spoiler entities
func (v *Validator) ValidateTextEntities(entities []TextEntity) error {
	if len(entities) == 0 {
		return nil // Optional field
	}

	// Check max limit
	if len(entities) > MaxTextEntities {
		return NewValidationError(400,
			"Too many text entities",
			fmt.Sprintf("Maximum %d text spoiler entities allowed per post (currently %d)", MaxTextEntities, len(entities)),
			"text_entities")
	}

	// Validate each entity
	for i, entity := range entities {
		if entity.EntityType == "" {
			return NewValidationError(400,
				"Text entity missing type",
				fmt.Sprintf("Text entity at index %d must have an entity_type", i),
				"text_entities")
		}

		if entity.EntityType != "SPOILER" && entity.EntityType != "spoiler" {
			return NewValidationError(400,
				"Invalid text entity type",
				fmt.Sprintf("Text entity at index %d has invalid type '%s' (must be 'SPOILER' or 'spoiler')", i, entity.EntityType),
				"text_entities")
		}

		if entity.Offset < 0 {
			return NewValidationError(400,
				"Invalid text entity offset",
				fmt.Sprintf("Text entity at index %d has negative offset %d", i, entity.Offset),
				"text_entities")
		}

		if entity.Length <= 0 {
			return NewValidationError(400,
				"Invalid text entity length",
				fmt.Sprintf("Text entity at index %d has non-positive length %d", i, entity.Length),
				"text_entities")
		}
	}

	return nil
}

// ValidateMediaURL validates media URLs for basic format and accessibility
func (v *Validator) ValidateMediaURL(mediaURL, mediaType string) error {
	if mediaURL == "" {
		return NewValidationError(400,
			"Media URL cannot be empty",
			fmt.Sprintf("%s URL is required", mediaType),
			"media_url")
	}

	// Basic URL format validation
	if !strings.HasPrefix(mediaURL, "http://") && !strings.HasPrefix(mediaURL, "https://") {
		return NewValidationError(400,
			"Invalid media URL format",
			"Media URL must start with http:// or https://",
			"media_url")
	}

	return nil
}

// ValidateTopicTag validates a topic tag according to Threads API rules
func (v *Validator) ValidateTopicTag(tag string) error {
	if tag == "" {
		return nil // Empty tag is valid (optional)
	}

	// Check for forbidden characters
	if strings.Contains(tag, ".") {
		return NewValidationError(400,
			"Invalid topic tag",
			"Topic tags cannot contain periods (.)",
			"topic_tag")
	}

	if strings.Contains(tag, "&") {
		return NewValidationError(400,
			"Invalid topic tag",
			"Topic tags cannot contain ampersands (&)",
			"topic_tag")
	}

	return nil
}

// ValidateCountryCodes validates ISO 3166-1 alpha-2 country codes
func (v *Validator) ValidateCountryCodes(codes []string) error {
	if len(codes) == 0 {
		return nil // Empty list is valid
	}

	for _, code := range codes {
		if len(code) != 2 {
			return NewValidationError(400,
				"Invalid country code",
				fmt.Sprintf("Country code '%s' must be 2 characters (ISO 3166-1 alpha-2)", code),
				"country_codes")
		}

		// Convert to uppercase for consistency
		code = strings.ToUpper(code)

		// Basic validation - should be alphabetic
		for _, char := range code {
			if char < 'A' || char > 'Z' {
				return NewValidationError(400,
					"Invalid country code",
					fmt.Sprintf("Country code '%s' must contain only letters", code),
					"country_codes")
			}
		}
	}

	return nil
}

// ValidateCarouselChildren validates carousel children count
func (v *Validator) ValidateCarouselChildren(childrenCount int) error {
	if childrenCount < MinCarouselItems {
		return NewValidationError(400,
			"Insufficient children",
			fmt.Sprintf("Carousel must have at least %d children", MinCarouselItems),
			"children")
	}

	if childrenCount > MaxCarouselItems {
		return NewValidationError(400,
			"Too many children",
			fmt.Sprintf("Carousel cannot have more than %d children", MaxCarouselItems),
			"children")
	}

	return nil
}

// ValidatePaginationOptions validates pagination parameters
func (v *Validator) ValidatePaginationOptions(opts *PaginationOptions) error {
	if opts == nil {
		return nil
	}

	if opts.Limit > MaxPostsPerRequest {
		return NewValidationError(400,
			"Limit too large",
			fmt.Sprintf("Maximum limit is %d posts per request", MaxPostsPerRequest),
			"limit")
	}

	return nil
}

// ValidatePostsOptions validates PostsOptions including pagination and timestamp fields.
func (v *Validator) ValidatePostsOptions(opts *PostsOptions) error {
	if opts == nil {
		return nil
	}

	if err := v.ValidatePaginationOptions(&PaginationOptions{
		Limit:  opts.Limit,
		Before: opts.Before,
		After:  opts.After,
	}); err != nil {
		return err
	}

	if opts.Since > 0 && opts.Since < MinSearchTimestamp {
		return NewValidationError(400, "Invalid since timestamp",
			fmt.Sprintf("since timestamp must be >= %d", MinSearchTimestamp), "since")
	}
	if opts.Until > 0 && opts.Until < MinSearchTimestamp {
		return NewValidationError(400, "Invalid until timestamp",
			fmt.Sprintf("until timestamp must be >= %d", MinSearchTimestamp), "until")
	}
	if opts.Since > 0 && opts.Until > 0 && opts.Since > opts.Until {
		return NewValidationError(400, "Invalid time range",
			"since timestamp must be less than or equal to until timestamp", "since")
	}

	return nil
}

// ValidateSearchOptions validates search parameters
func (v *Validator) ValidateSearchOptions(opts *SearchOptions) error {
	if opts == nil {
		return nil
	}

	if opts.Limit > MaxPostsPerRequest {
		return NewValidationError(400,
			"Limit too large",
			fmt.Sprintf("Maximum limit is %d posts per request", MaxPostsPerRequest),
			"limit")
	}

	if opts.Since > 0 && opts.Since < MinSearchTimestamp {
		return NewValidationError(400,
			"Invalid since timestamp",
			fmt.Sprintf("Since timestamp must be greater than or equal to %d", MinSearchTimestamp),
			"since")
	}

	return nil
}

// ValidateGIFAttachment validates GIF attachment structure and content
func (v *Validator) ValidateGIFAttachment(gifAttachment *GIFAttachment) error {
	if gifAttachment == nil {
		return nil // GIF attachment is optional
	}

	// Validate GIF ID is provided
	if strings.TrimSpace(gifAttachment.GIFID) == "" {
		return NewValidationError(400,
			"GIF ID required",
			"GIF attachment must have a gif_id field",
			"gif_attachment.gif_id")
	}

	// Validate provider is provided and valid
	if gifAttachment.Provider == "" {
		return NewValidationError(400,
			"GIF provider required",
			"GIF attachment must have a provider field",
			"gif_attachment.provider")
	}

	// Validate provider is a supported value
	if gifAttachment.Provider != GIFProviderTenor && gifAttachment.Provider != GIFProviderGiphy {
		return NewValidationError(400,
			"Invalid GIF provider",
			fmt.Sprintf("GIF provider '%s' is not supported. Supported providers: 'TENOR', 'GIPHY'", gifAttachment.Provider),
			"gif_attachment.provider")
	}

	return nil
}

// ConfigValidator validates client configuration
type ConfigValidator struct{}

// NewConfigValidator creates a new config validator
func NewConfigValidator() *ConfigValidator {
	return &ConfigValidator{}
}

// Validate validates the entire configuration
func (cv *ConfigValidator) Validate(c *Config) error {
	validators := []func(*Config) error{
		cv.validateRequiredFields,
		cv.validateRedirectURI,
		cv.validateScopes,
		cv.validateHTTPSettings,
		cv.validateRetryConfig,
	}

	for _, validator := range validators {
		if err := validator(c); err != nil {
			return err
		}
	}
	return nil
}

// validateRequiredFields checks all required fields are present
func (cv *ConfigValidator) validateRequiredFields(c *Config) error {
	if c.ClientID == "" {
		return fmt.Errorf("ClientID is required")
	}

	if c.ClientSecret == "" {
		return fmt.Errorf("ClientSecret is required")
	}

	if c.RedirectURI == "" {
		return fmt.Errorf("RedirectURI is required")
	}

	return nil
}

// validateRedirectURI validates the redirect URI format
func (cv *ConfigValidator) validateRedirectURI(c *Config) error {
	if !strings.HasPrefix(c.RedirectURI, "http://") && !strings.HasPrefix(c.RedirectURI, "https://") {
		return fmt.Errorf("RedirectURI must be a valid HTTP or HTTPS URL")
	}
	return nil
}

// validateScopes validates the configured scopes
func (cv *ConfigValidator) validateScopes(c *Config) error {
	if len(c.Scopes) == 0 {
		return fmt.Errorf("at least one scope is required")
	}

	validScopes := map[string]bool{
		"threads_basic":             true,
		"threads_content_publish":   true,
		"threads_manage_insights":   true,
		"threads_manage_replies":    true,
		"threads_read_replies":      true,
		"threads_manage_mentions":   true,
		"threads_keyword_search":    true,
		"threads_delete":            true,
		"threads_location_tagging":  true,
		"threads_profile_discovery": true,
	}

	for _, scope := range c.Scopes {
		if !validScopes[scope] {
			return fmt.Errorf("invalid scope: %s", scope)
		}
	}

	return nil
}

// validateHTTPSettings validates HTTP-related configuration
func (cv *ConfigValidator) validateHTTPSettings(c *Config) error {
	if c.HTTPTimeout <= 0 {
		return fmt.Errorf("HTTPTimeout must be positive")
	}

	if c.BaseURL == "" {
		return fmt.Errorf("BaseURL is required")
	}

	if !strings.HasPrefix(c.BaseURL, "http://") && !strings.HasPrefix(c.BaseURL, "https://") {
		return fmt.Errorf("BaseURL must be a valid HTTP or HTTPS URL")
	}

	return nil
}

// validateRetryConfig validates retry configuration
func (cv *ConfigValidator) validateRetryConfig(c *Config) error {
	if c.RetryConfig == nil {
		return nil
	}

	if c.RetryConfig.MaxRetries < 0 {
		return fmt.Errorf("RetryConfig.MaxRetries must be non-negative")
	}

	if c.RetryConfig.InitialDelay <= 0 {
		return fmt.Errorf("RetryConfig.InitialDelay must be positive")
	}

	if c.RetryConfig.MaxDelay <= 0 {
		return fmt.Errorf("RetryConfig.MaxDelay must be positive")
	}

	if c.RetryConfig.BackoffFactor <= 0 {
		return fmt.Errorf("RetryConfig.BackoffFactor must be positive")
	}

	if c.RetryConfig.InitialDelay > c.RetryConfig.MaxDelay {
		return fmt.Errorf("RetryConfig.InitialDelay cannot be greater than MaxDelay")
	}

	return nil
}