package main

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"slices"
	"strings"
	"time"

	"go.mau.fi/whatsmeow"
	"go.mau.fi/whatsmeow/proto/waE2E"
	"go.mau.fi/whatsmeow/types"
)

const (
	// whatsappSendTime is the longest time of a send.
	whatsappSendTime = 30 * time.Second

	// whatsappSendBytes is the most bytes of the text of a send.
	whatsappSendBytes = 65536

	// whatsappSendIDBytes is the most bytes of the ID of a send.
	whatsappSendIDBytes = 100

	// The states of a send record.
	whatsappSending = "sending"
	whatsappSent    = "sent"
	whatsappFailed  = "failed"
)

// whatsappSend sends text to chat, the ID of a private chat or a group, and
// returns the answer of the tool. id names the send: a call with an id that has
// a record gives the answer of the record and sends nothing, and the same id
// with another chat or text is an error. The record "sending" is durable before
// the send, so a stop of the daemon during the send gives an answer that the
// result is unknown, and not a second send. A disconnected WhatsApp sends
// nothing and makes no record. link gives the device, the client, and the own
// IDs, groups the names of the groups, and state the send records. The clock
// gives the times of the records and the time zone of the answer.
func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups, state *WhatsAppState, clock func() time.Time, id, chat, text string) (string, error) {
	if !link.linked {
		return whatsappNotLinked, nil
	}

	jid, err := whatsappSendCheck(id, chat, text, link.own)
	if err != nil {
		return "", err
	}

	digest := sha256.Sum256([]byte(text))
	record := WhatsAppSend{
		ID:     id,
		Chat:   chat,
		Digest: hex.EncodeToString(digest[:]),
		State:  whatsappSending,
		Time:   clock(),
	}

	held, found := state.Send(id)
	switch {
	case found && (held.Chat != record.Chat || held.Digest != record.Digest):
		return "", fmt.Errorf("the id %s belongs to another message: give a new id for each message", id)
	case found && held.State == whatsappSending:
		return "The send with this id started, but its result is unknown, because the daemon stopped during it. Ask the user to look at the chat in WhatsApp before you send the message again with a new id.", nil
	case found:
		return held.Answer + " This is the answer of the first call with this id: nothing was sent again.", nil
	case link.client == nil || !link.connected:
		return "", errors.New("WhatsApp is disconnected, so nothing was sent: try again later")
	}

	record.MessageID = link.client.GenerateMessageID()
	err = state.PutSend(record)
	if err != nil {
		return "", err
	}

	sendCtx, cancel := context.WithTimeout(ctx, whatsappSendTime)
	defer cancel()

	response, err := link.client.SendMessage(sendCtx, jid, &waE2E.Message{
		Conversation: new(text),
	}, whatsmeow.SendRequestExtra{
		ID: record.MessageID,
	})

	record.State = whatsappSent
	if err != nil {
		record.State = whatsappFailed
		record.Answer = "The send failed: " + whatsappRedact(link.own, err.Error()) + "."
	} else {
		name := groups.name(ctx, link, jid.String())
		if jid.Server != types.GroupServer {
			name = whatsappContactName(ctx, link.device, jid, "")
		}

		record.Answer = "Sent to " + name + " at " + response.Timestamp.In(clock().Location()).Format("15:04") + "."
	}

	err = state.PutSend(record)
	if err != nil {
		return "", err
	}

	return record.Answer, nil
}

// whatsappSendCheck returns the JID of chat, and an error when id, chat, or
// text cannot go to a send. The chat is a private chat or a group, and not the
// chat of the user with itself.
func whatsappSendCheck(id, chat, text string, own []string) (types.JID, error) {
	jid, err := types.ParseJID(chat)
	switch {
	case strings.TrimSpace(id) == "" || len(id) > whatsappSendIDBytes:
		return types.EmptyJID, fmt.Errorf("the id must have 1 to %d bytes", whatsappSendIDBytes)
	case strings.TrimSpace(text) == "" || len(text) > whatsappSendBytes:
		return types.EmptyJID, fmt.Errorf("the text must have 1 to %d bytes", whatsappSendBytes)
	case err != nil || jid.User == "" || jid != jid.ToNonAD() || jid.String() != chat:
		return types.EmptyJID, fmt.Errorf("%q is not the ID of a WhatsApp chat: find the ID with whatsapp_find", chat)
	case jid.Server != types.DefaultUserServer && jid.Server != types.HiddenUserServer && jid.Server != types.GroupServer:
		return types.EmptyJID, fmt.Errorf("%q is not a private chat or a group", chat)
	case slices.Contains(own, jid.User):
		return types.EmptyJID, errors.New("this is the chat of the user with itself: send to another chat")
	}

	return jid, nil
}