package v1

import (
	"encoding/json"
	"strings"

	"github.com/gochat/gochat/internal/model"
)

func inboxListResponse(inboxes []model.Inbox) map[string]any {
	payload := make([]any, 0, len(inboxes))
	for i := range inboxes {
		payload = append(payload, serializeInbox(&inboxes[i]))
	}
	return map[string]any{"payload": payload}
}

func serializeInbox(inbox *model.Inbox) map[string]any {
	config := parseInboxChannelConfig(inbox.ChannelConfig)
	payload := map[string]any{
		"id":                            inbox.ID,
		"avatar_url":                    inbox.AvatarURL,
		"channel_id":                    inbox.ChannelID,
		"name":                          inbox.Name,
		"channel_type":                  chatwootChannelType(inbox.ChannelType),
		"greeting_enabled":              inbox.GreetingEnabled,
		"greeting_message":              inbox.GreetingMessage,
		"working_hours_enabled":         inbox.WorkingHoursEnabled,
		"enable_email_collect":          inbox.EnableEmailCollect,
		"csat_survey_enabled":           inbox.CsatSurveyEnabled,
		"csat_config":                   jsonStringObject(inbox.CsatConfig),
		"enable_auto_assignment":        inbox.EnableAutoAssignment,
		"auto_assignment_config":        configValue(config, "auto_assignment_config"),
		"out_of_office_message":         inbox.OutOfOfficeMessage,
		"working_hours":                 configArray(config, "working_hours"),
		"timezone":                      inbox.Timezone,
		"callback_webhook_url":          configValue(config, "callback_webhook_url"),
		"allow_messages_after_resolved": inbox.AllowMessagesAfterResolved,
		"lock_to_single_conversation":   inbox.LockToSingleConversation,
		"sender_name_type":              inbox.SenderNameType,
		"business_name":                 inbox.BusinessName,
		"allowed_domains":               configValue(config, "allowed_domains"),
		"widget_color":                  configValue(config, "widget_color"),
		"website_url":                   configValue(config, "website_url"),
		"hmac_mandatory":                configValue(config, "hmac_mandatory"),
		"welcome_title":                 configValue(config, "welcome_title"),
		"welcome_tagline":               configValue(config, "welcome_tagline"),
		"web_widget_script":             configValue(config, "web_widget_script"),
		"website_token":                 configValue(config, "website_token"),
		"selected_feature_flags":        configValue(config, "selected_feature_flags"),
		"reply_time":                    configValue(config, "reply_time"),
		"provider":                      configValue(config, "provider"),
	}

	switch chatwootChannelType(inbox.ChannelType) {
	case "Channel::WebWidget":
		payload["hmac_token"] = configValue(config, "hmac_token")
		payload["pre_chat_form_enabled"] = configValue(config, "pre_chat_form_enabled")
		payload["pre_chat_form_options"] = configValue(config, "pre_chat_form_options")
		payload["continuity_via_email"] = configValue(config, "continuity_via_email")
	case "Channel::Api":
		payload["hmac_token"] = configValue(config, "hmac_token")
		payload["secret"] = inbox.Secret
		payload["webhook_url"] = inbox.WebhookURL
		payload["inbox_identifier"] = firstConfigValue(config, "inbox_identifier", "identifier")
		payload["additional_attributes"] = configValue(config, "additional_attributes")
	case "Channel::Telegram":
		payload["bot_name"] = configValue(config, "bot_name")
	case "Channel::FacebookPage":
		payload["page_id"] = configValue(config, "page_id")
		payload["reauthorization_required"] = configValue(config, "reauthorization_required")
	case "Channel::Instagram":
		payload["instagram_id"] = configValue(config, "instagram_id")
		payload["reauthorization_required"] = configValue(config, "reauthorization_required")
	case "Channel::Tiktok":
		payload["reauthorization_required"] = configValue(config, "reauthorization_required")
	case "Channel::TwilioSms":
		payload["messaging_service_sid"] = configValue(config, "messaging_service_sid")
		payload["phone_number"] = configValue(config, "phone_number")
		payload["medium"] = configValue(config, "medium")
		payload["content_templates"] = configValue(config, "content_templates")
		payload["auth_token"] = configValue(config, "auth_token")
		payload["account_sid"] = configValue(config, "account_sid")
		payload["api_key_sid"] = configValue(config, "api_key_sid")
	case "Channel::Email":
		payload["email"] = configValue(config, "email")
		payload["forwarding_enabled"] = false
		payload["imap_enabled"] = configValue(config, "imap_enabled")
		payload["smtp_enabled"] = configValue(config, "smtp_enabled")
	case "Channel::Whatsapp":
		payload["message_templates"] = configValue(config, "message_templates")
		payload["provider_config"] = configValue(config, "provider_config")
		payload["reauthorization_required"] = configValue(config, "reauthorization_required")
	}

	return payload
}

func chatwootChannelType(channelType string) string {
	if strings.HasPrefix(channelType, "Channel::") {
		return channelType
	}
	aliases := map[string]string{
		"web_widget": "Channel::WebWidget",
		"facebook":   "Channel::FacebookPage",
		"instagram":  "Channel::Instagram",
		"twitter":    "Channel::TwitterProfile",
		"twilio_sms": "Channel::TwilioSms",
		"whatsapp":   "Channel::Whatsapp",
		"api":        "Channel::Api",
		"email":      "Channel::Email",
		"telegram":   "Channel::Telegram",
		"line":       "Channel::Line",
		"sms":        "Channel::Sms",
		"tiktok":     "Channel::Tiktok",
	}
	if mapped, ok := aliases[channelType]; ok {
		return mapped
	}
	return channelType
}

func parseInboxChannelConfig(raw string) map[string]any {
	if raw == "" {
		return map[string]any{}
	}
	var config map[string]any
	if err := json.Unmarshal([]byte(raw), &config); err != nil {
		return map[string]any{}
	}
	return config
}

func configValue(config map[string]any, key string) any {
	if value, ok := config[key]; ok {
		return value
	}
	return nil
}

func firstConfigValue(config map[string]any, keys ...string) any {
	for _, key := range keys {
		if value, ok := config[key]; ok {
			return value
		}
	}
	return nil
}

func configArray(config map[string]any, key string) any {
	if value, ok := config[key]; ok {
		return value
	}
	return []any{}
}

func jsonStringObject(raw string) any {
	if raw == "" {
		return map[string]any{}
	}
	var value any
	if err := json.Unmarshal([]byte(raw), &value); err != nil {
		return map[string]any{}
	}
	return value
}