package main

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

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

const (
	// whatsappSendTimeout is the longest time of a send.
	whatsappSendTimeout = 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 and an optional stored image 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, text, or image 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, and logger gets one line for each send. The clock
// gives the times of the records and the time zone of the answer. Image names
// are checked before the record is written, and uploads start only after the
// record is durable. Text-only records keep their text digest.
func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups, state *WhatsAppState, images *ImageStore, logger *slog.Logger, clock func() time.Time, id, chat, text, image string) (string, error) {
	if !link.linked {
		return whatsappNotLinked, nil
	}

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

	digest := sha256.Sum256([]byte(text))
	record := WhatsAppSend{
		ID:     id,
		Image:  image,
		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 || held.Image != record.Image):
		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")
	}

	var data []byte

	if image != "" {
		data, err = images.Read(image)
		if err != nil {
			return "", fmt.Errorf("read image to send: %w", err)
		}
	}

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

	message := &waE2E.Message{Conversation: new(text)}
	if image != "" {
		message, err = whatsappImageMessage(ctx, link.client, data, text)
	}

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

	var response whatsmeow.SendResponse

	if err == nil {
		response, err = link.client.SendMessage(sendCtx, jid, message, whatsmeow.SendRequestExtra{
			ID: record.MessageID,
		})
		if err != nil && image != "" {
			err = fmt.Errorf("send image: %w", whatsappImageSendError(err))
		}
	}

	record.State = whatsappSent
	if err != nil {
		record.State = whatsappFailed
		record.Answer = "The send failed: " + whatsappRedact(link.own, err.Error()) + "."
		logger.Warn("message send failed", "chat", whatsappChatHash(jid), "image", image != "", "err", whatsappRedact(append(slices.Clone(link.own), jid.User), err.Error()))
	} else {
		logger.Info("message sent", "chat", whatsappChatHash(jid), "image", image != "")

		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. Text can be empty only with an image. The chat is a
// private chat or a group, and not the chat of the user with itself.
func whatsappSendCheck(id, chat, text, image 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) == "" && image == "") || 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
}