package main

import (
	"context"
	"io"
	"log"
	"os"
	"path/filepath"
	"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",
	}

	// 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 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, and a logout with logoutErr. groups are the groups of the
// account.
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
	phones     []string
	logouts    int
}

// ConnectContext tells the test that the daemon connected.
func (f *WhatsAppFake) ConnectContext(ctx context.Context) error {
	f.connects <- struct{}{}

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

	return f.connectErr
}

// 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
}

// 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
}

// 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),
		},
	}
}