package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"slices"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"go.mau.fi/whatsmeow"
	waAdv "go.mau.fi/whatsmeow/proto/waAdv"
	"go.mau.fi/whatsmeow/proto/waE2E"
	"go.mau.fi/whatsmeow/store"
	"go.mau.fi/whatsmeow/store/sqlstore"
	"go.mau.fi/whatsmeow/types"
	"go.mau.fi/whatsmeow/types/events"
	waLog "go.mau.fi/whatsmeow/util/log"
)

const (
	// whatsappTestNumber is the phone number of the own account in the
	// tests. It is a number for fiction.
	whatsappTestNumber = "15550001111"

	// whatsappTestLID is the LID of the own account in the tests.
	whatsappTestLID = "987654321012345"

	// whatsappTestCode is the pairing code of the fake.
	whatsappTestCode = "ABCD-EFGH"
)

var (
	// whatsappTestOwn is the own account in the tests.
	whatsappTestOwn = types.NewJID(whatsappTestNumber, types.DefaultUserServer)

	// whatsappTestAna is a contact in the tests.
	whatsappTestAna = types.NewJID("15550002222", types.DefaultUserServer)

	// whatsappTestBruno is a member of the test group.
	whatsappTestBruno = types.NewJID("15550003333", types.DefaultUserServer)

	// whatsappTestFamily is the test group.
	whatsappTestFamily = types.NewJID("120363000000000001", types.GroupServer)

	// whatsappTestChat is the private chat with whatsappTestAna.
	whatsappTestChat = WhatsAppChat{
		ID:   whatsappTestAna.String(),
		Name: "Ana Souza",
	}

	// whatsappTestSendTime is the time of the sends of the fake.
	whatsappTestSendTime = time.Date(2026, 1, 1, 12, 5, 0, 0, time.UTC)

	// whatsappTestGroup is the chat of whatsappTestFamily.
	whatsappTestGroup = WhatsAppChat{
		ID:    whatsappTestFamily.String(),
		Name:  "Family",
		Group: true,
	}
)

// WhatsAppFake is a fake WhatsApp client. It keeps the event handler that the
// daemon gives it, and Emit gives events to the handler, as the library does.
// Each connection keeps its context and sends to connects, and each pairing
// sends its channel to pairings, so that the test gives the items of the
// pairing. A connection fails with connectErr, a logout with logoutErr, and a
// send with sendErr. groups are the groups of the account. A send that does not
// fail gets the time whatsappTestSendTime.
type WhatsAppFake struct {
	connects chan struct{}
	pairings chan chan whatsmeow.QRChannelItem

	mutex       sync.Mutex
	handle      func(event any) bool
	connectErr  error
	logoutErr   error
	groups      []*types.GroupInfo
	sendErr     error
	phones      []string
	logouts     int
	sent        []WhatsAppFakeSend
	connections []context.Context
}

// ConnectContext keeps ctx and tells the test that the daemon connected.
func (f *WhatsAppFake) ConnectContext(ctx context.Context) error {
	f.mutex.Lock()
	f.connections = append(f.connections, ctx)
	f.mutex.Unlock()

	f.connects <- struct{}{}

	f.mutex.Lock()
	defer f.mutex.Unlock()

	return f.connectErr
}

// Connections returns the contexts of the connections, in order.
func (f *WhatsAppFake) Connections() []context.Context {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return slices.Clone(f.connections)
}

// Disconnect does nothing.
func (f *WhatsAppFake) Disconnect() {
}

// GetQRChannel gives a new channel of pairing items to the test.
func (f *WhatsAppFake) GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error) {
	items := make(chan whatsmeow.QRChannelItem, 8)
	f.pairings <- items

	return items, nil
}

// PairPhone keeps phone and returns whatsappTestCode.
func (f *WhatsAppFake) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error) {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	f.phones = append(f.phones, phone)

	return whatsappTestCode, nil
}

// Logout counts the logouts and returns logoutErr.
func (f *WhatsAppFake) Logout(ctx context.Context) error {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	f.logouts++

	return f.logoutErr
}

// GetJoinedGroups returns groups.
func (f *WhatsAppFake) GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return f.groups, nil
}

// GenerateMessageID returns a new message ID.
func (f *WhatsAppFake) GenerateMessageID() types.MessageID {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return fmt.Sprintf("MSG%d", len(f.sent)+1)
}

// SendMessage keeps the send and returns sendErr.
func (f *WhatsAppFake) SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error) {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	f.sent = append(f.sent, WhatsAppFakeSend{
		to:   to.String(),
		text: message.GetConversation(),
		id:   extra[0].ID,
	})

	if f.sendErr != nil {
		return whatsmeow.SendResponse{}, f.sendErr
	}

	return whatsmeow.SendResponse{
		Timestamp: whatsappTestSendTime,
	}, nil
}

// Sent returns the sends.
func (f *WhatsAppFake) Sent() []WhatsAppFakeSend {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return slices.Clone(f.sent)
}

// Phones returns the phone numbers of the pairings.
func (f *WhatsAppFake) Phones() []string {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return append([]string{}, f.phones...)
}

// Logouts returns the number of logouts.
func (f *WhatsAppFake) Logouts() int {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	return f.logouts
}

// Emit gives event to the handler of the daemon and returns its answer.
func (f *WhatsAppFake) Emit(event any) bool {
	f.mutex.Lock()
	handle := f.handle
	f.mutex.Unlock()

	return handle(event)
}

// newClient keeps handle and returns the fake as the client of device.
func (f *WhatsAppFake) newClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
	f.mutex.Lock()
	defer f.mutex.Unlock()

	f.handle = handle

	return f
}

// WhatsAppFakeSend is one send of the fake: the chat, the text, and the message
// ID.
type WhatsAppFakeSend struct {
	to   string
	text string
	id   string
}

// whatsappStartTest opens the WhatsApp of the data directory dir with a fake
// client and the test clock, and closes it at the end of the test. The daemon
// log goes to the returned buffer.
func whatsappStartTest(t *testing.T, dir string, clock *TestClock) (*WhatsApp, *WhatsAppFake, *SyncBuffer) {
	t.Helper()

	fake := &WhatsAppFake{
		connects: make(chan struct{}, 16),
		pairings: make(chan chan whatsmeow.QRChannelItem, 16),
	}

	logs := &SyncBuffer{}
	whatsapp, err := openWhatsApp(t.Context(), dir, clock.Now, log.New(logs, "", 0), fake.newClient)
	require.NoError(t, err)

	t.Cleanup(func() {
		require.NoError(t, whatsapp.Close())
	})

	return whatsapp, fake, logs
}

// whatsappTestSession writes a session database with mode 0600 to the data
// directory dir. When linked is true, it holds a device linked to
// whatsappTestNumber and whatsappTestLID, and else no device.
func whatsappTestSession(t *testing.T, dir string, linked bool) {
	t.Helper()

	path := filepath.Join(dir, whatsappDirName, whatsappSessionFileName)
	require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o700))
	require.NoError(t, os.WriteFile(path, nil, 0o600))

	address, err := whatsappSessionAddress(path)
	require.NoError(t, err)

	container, err := sqlstore.New(t.Context(), "sqlite", address, waLog.Noop)
	require.NoError(t, err)

	if linked {
		device := container.NewDevice()
		jid := types.NewADJID(whatsappTestNumber, 0, 1)
		device.ID = &jid
		device.LID = types.NewADJID(whatsappTestLID, 0, 1)
		device.LID.Server = types.HiddenUserServer
		device.Account = &waAdv.ADVSignedDeviceIdentity{
			Details:             []byte{},
			AccountSignature:    make([]byte, 64),
			AccountSignatureKey: make([]byte, 32),
			DeviceSignature:     make([]byte, 64),
		}
		require.NoError(t, device.Save(t.Context()))
	}

	require.NoError(t, container.Close())
}

// whatsappDiscardLog is a logger for a WhatsApp whose log a test does not read.
func whatsappDiscardLog() *log.Logger {
	return log.New(io.Discard, "", 0)
}

// whatsappTestMessage returns the event of the text message id of sender in
// chat at the time at. A sender with whatsappTestNumber is the user.
func whatsappTestMessage(chat, sender types.JID, id, text string, at time.Time) *events.Message {
	return &events.Message{
		Info: types.MessageInfo{
			MessageSource: types.MessageSource{
				Chat:     chat,
				Sender:   sender,
				IsFromMe: sender.User == whatsappTestNumber,
				IsGroup:  chat.Server == types.GroupServer,
			},
			ID:        id,
			Timestamp: at,
		},
		Message: &waE2E.Message{
			Conversation: new(text),
		},
	}
}

// whatsappTestLogTexts returns the texts of the messages in the log of memory,
// after the log holds at least one message.
func whatsappTestLogTexts(t *testing.T, memory *Memory) []string {
	t.Helper()

	require.Eventually(t, func() bool {
		return memory.Len() > 0
	}, 10*time.Second, time.Millisecond)

	var texts []string
	for id := range memory.Len() {
		message, err := memory.Message(id)
		require.NoError(t, err)

		texts = append(texts, message.Text)
	}

	return texts
}

// whatsappStartTestLinked opens a WhatsApp with a linked device in a temporary
// directory, with a quiet time of 50 ms for its batches.
func whatsappStartTestLinked(t *testing.T) (*WhatsApp, *WhatsAppFake) {
	t.Helper()

	dir := t.TempDir()
	whatsappTestSession(t, dir, true)
	whatsapp, fake, _ := whatsappStartTest(t, dir, newTestClock())
	whatsapp.state.quiet = 50 * time.Millisecond

	return whatsapp, fake
}

// whatsappTestConnect waits for the connection of the daemon and gives it the
// events of a connection with an empty catch-up.
func whatsappTestConnect(t *testing.T, fake *WhatsAppFake) {
	t.Helper()

	<-fake.connects
	require.True(t, fake.Emit(&events.Connected{}))
	require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
}