package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"net/url"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"sync"
	"time"

	"go.mau.fi/whatsmeow"
	"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"

	// The session store of the library opens SQLite with this pure Go
	// driver.
	_ "modernc.org/sqlite"
)

const (
	// whatsappDirName is the directory of the WhatsApp files in the data
	// directory.
	whatsappDirName = "whatsapp"

	// whatsappSessionFileName is the session database of the library in
	// whatsappDirName.
	whatsappSessionFileName = "session.db"

	// whatsappCommand starts the input lines of the WhatsApp commands, such
	// as "/whatsapp status".
	whatsappCommand = "/whatsapp"

	// whatsappUsage is the answer to a WhatsApp command that does not
	// exist.
	whatsappUsage = "Use /whatsapp pair PHONE, /whatsapp status, or /whatsapp unlink. PHONE is the number of your WhatsApp account with its country code, such as +15550001111."

	// whatsappPairSteps tells the user what to do with the pairing code,
	// which comes in the next message.
	whatsappPairSteps = "In WhatsApp on your phone, open Linked devices, tap Link a device, then tap Link with phone number instead, and enter the code of the next message. The code expires in about 2 minutes."

	// whatsappPairExpired is the answer when the pairing code expires.
	whatsappPairExpired = "The pairing code expired. Run /whatsapp pair PHONE again for a new code."

	// whatsappTimeLayout is the layout of the times in the answers.
	whatsappTimeLayout = "2006-01-02 15:04"

	// whatsappPairTime is the longest time of a pairing. The library closes
	// the pairing connection after about 160 seconds.
	whatsappPairTime = 3 * time.Minute

	// whatsappLogoutTime is the longest time of the logout call of an
	// unlink.
	whatsappLogoutTime = 30 * time.Second

	// whatsappNoticeDelay is how long a disconnection lasts before the user
	// gets a notice.
	whatsappNoticeDelay = 10 * time.Minute

	// whatsappRequests is the number of pair and unlink commands that can
	// wait for Run.
	whatsappRequests = 8

	// whatsappSource is the source of the work events of the batches.
	whatsappSource = "whatsapp"

	// whatsappLookupTime is the longest time of a read of the names in the
	// session database or of the groups from WhatsApp.
	whatsappLookupTime = 10 * time.Second

	// whatsappGroupsRefresh is the shortest time between two reads of the
	// groups from WhatsApp for a group with no name.
	whatsappGroupsRefresh = time.Minute

	// whatsappUnknownGroup is the name of a group whose name is not known.
	whatsappUnknownGroup = "A group with no known name"

	// whatsappCatchupLimit is the longest wait for the end of the catch-up
	// after a connection.
	whatsappCatchupLimit = time.Minute
)

// WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
// real one is a *whatsmeow.Client from whatsappNewClient, and the tests use a
// fake.
type WhatsAppClient interface {
	ConnectContext(ctx context.Context) error
	Disconnect()
	GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error)
	PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
	Logout(ctx context.Context) error
	GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error)
}

// openWhatsApp opens the WhatsApp session in the data directory dir. Without
// the session file, WhatsApp is not linked. The session gives full access to
// the account, so a file that another user can read is an error. The clock
// gives the times of the status, logger gets the failures, and newClient makes
// the client of a device with its event handler.
func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {
	w := &WhatsApp{
		dir:          filepath.Join(dir, whatsappDirName),
		clock:        clock,
		logger:       logger,
		newClient:    newClient,
		noticeDelay:  whatsappNoticeDelay,
		catchupLimit: whatsappCatchupLimit,
		requests:     make(chan WhatsAppRequest, whatsappRequests),
		logouts:      make(chan struct{}, 1),
		wake:         make(chan struct{}, 1),
		failures:     make(chan error, 1),
		groupNames:   make(map[string]string),
	}

	var err error
	w.batches, err = openWhatsAppBatches(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
	if err != nil {
		return nil, err
	}

	info, err := os.Stat(w.sessionPath())
	if errors.Is(err, os.ErrNotExist) {
		return w, nil
	}

	if err != nil {
		return nil, fmt.Errorf("read WhatsApp session: %w", err)
	}

	if info.Mode().Perm()&0o077 != 0 {
		return nil, fmt.Errorf("%s holds the WhatsApp session, so its mode must be 0600", filepath.Join(whatsappDirName, whatsappSessionFileName))
	}

	err = w.openSession(ctx)
	if err != nil {
		return nil, err
	}

	if w.device.ID != nil {
		w.linked = true
		w.catchingUp = true
		w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
	}

	return w, nil
}

// WhatsApp is the link of the daemon to the WhatsApp account of the user, as a
// linked device. The session database of the library in dir holds the keys of
// the device. Run keeps a linked device connected, and the library connects
// again by itself after a network failure.
//
// The commands pair and unlink go to Run as requests, and Run runs one at a
// time. A pairing runs in its own goroutine until its code expires, and a new
// pairing ends the one before. Its phone number and code go only to the answer
// of the client that asked. A logout from the phone comes as an event of the
// library, and Run deletes the session. The mutex protects the session, the
// client, and the state of the connection, which the event handler of the
// library changes from its own goroutines.
//
// The text messages go into batches, one chat at a time, as WhatsAppBatches
// says. Run logs each closed batch as a work message that starts with
// [WhatsApp], and a batch that needs the user wakes the turn loop.
//
// After each connection, the servers send the messages that came while the
// daemon was away, and then OfflineSyncCompleted. Until then, or until
// catchupLimit passes, the closed batches wait in the state file. At the end of
// the catch-up, Run closes all batches, logs them, and wakes the turn loop
// once, so the whole catch-up gives one turn and not one turn for each chat.
// The batches of the state file at the start wait for the first catch-up in the
// same way. The event handler acknowledges a message only after the state file
// holds it, so the servers send again a message that a crash lost. A batch
// leaves the state file only after its work message is durable in the log. A
// crash between the two makes the batch repeat once.
//
// The library logs nothing, because its log lines hold the ID of the own
// account, which is the phone number of the user. The own number and the own
// LID never go to the log of the agent or to the log of the daemon: redact
// removes them from the errors, and a batch shows the messages of the user as
// You and a mention of the user as @you. The IDs of the other chats go to the
// log, and those of private chats hold phone numbers, because the agent needs
// them to send.
type WhatsApp struct {
	dir          string
	clock        func() time.Time
	logger       *log.Logger
	newClient    func(device *store.Device, handle func(event any) bool) WhatsAppClient
	noticeDelay  time.Duration
	catchupLimit time.Duration
	requests     chan WhatsAppRequest
	logouts      chan struct{}
	wake         chan struct{}
	failures     chan error
	batches      *WhatsAppBatches

	mutex          sync.Mutex
	container      *sqlstore.Container
	device         *store.Device
	client         WhatsAppClient
	linked         bool
	own            []string
	notify         func(Event)
	connected      bool
	connectedAt    time.Time
	disconnectedAt time.Time
	disconnections int
	noticed        bool
	timer          *time.Timer
	closed         bool
	groupNames     map[string]string
	groupsAt       time.Time
	catchingUp     bool
	caughtUp       bool
	catchups       int
	catchupTimer   *time.Timer
}

// Run connects a linked device, logs the closed batches in l, runs the pair and
// unlink commands, and handles a logout from the phone, until ctx ends. Its
// notes go to the log of l, and notify gets the notices for all clients. A
// failed first connection is logged, and the library tries again when the
// failure is one of the network. Run returns the error of a write of the log or
// of the state file, which stops the daemon, because then messages would be
// lost.
func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error {
	w.mutex.Lock()
	w.notify = notify
	linked := w.linked
	w.mutex.Unlock()

	if linked {
		w.connect(ctx)
	}

	var pairing sync.WaitGroup
	cancel := func() {}
	defer func() {
		cancel()
		pairing.Wait()
		w.close()
	}()

	for {
		err := w.deliver(ctx, l, false)
		if err != nil {
			return err
		}

		var due <-chan time.Time
		wait, open := w.batches.Wait(time.Now())
		if open {
			due = time.After(wait)
		}

		select {
		case <-ctx.Done():
			return nil
		case err = <-w.failures:
			return err
		case <-w.wake:
		case <-due:
		case <-w.logouts:
			err = w.loggedOut(ctx, l)
			if err != nil {
				return err
			}
		case request := <-w.requests:
			cancel()
			pairing.Wait()
			cancel = func() {}

			switch {
			case request.unlink:
				err = w.unlink(ctx, l, request.answer)
				if err != nil {
					return err
				}
			case w.isLinked():
				request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
			default:
				pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTime)
				cancel = cancelPair
				pairing.Go(func() {
					defer cancelPair()

					w.pair(pairCtx, l, request.phone, request.answer)
				})
			}
		}
	}
}

// Command runs the WhatsApp command args, the text after /whatsapp, and gives
// each answer to answer. The answers go only to the client that sent the
// command.
func (w *WhatsApp) Command(args string, answer func(text string)) {
	fields := strings.Fields(args)
	request := WhatsAppRequest{
		answer: answer,
	}

	switch {
	case len(fields) == 1 && fields[0] == "status":
		answer(w.Status())
		return
	case len(fields) == 1 && fields[0] == "unlink":
		request.unlink = true
	case len(fields) >= 2 && fields[0] == "pair":
		phone, valid := whatsappPhone(strings.Join(fields[1:], ""))
		if !valid {
			answer("PHONE must be the number of your WhatsApp account with its country code: 7 to 15 digits, such as +15550001111.")
			return
		}

		request.phone = phone
	default:
		answer(whatsappUsage)
		return
	}

	select {
	case w.requests <- request:
	default:
		answer("Too many WhatsApp commands wait. Try again in a minute.")
	}
}

// Status returns the state of the link: not linked, linked and connected, or
// linked and disconnected, with the times of the connection. It never holds the
// phone number.
func (w *WhatsApp) Status() string {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	switch {
	case !w.linked:
		return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it."
	case w.connected:
		return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "."
	case w.disconnectedAt.IsZero():
		return "WhatsApp is linked and not connected yet."
	case w.connectedAt.IsZero():
		return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "."
	default:
		return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "."
	}
}

// Close closes the session database.
func (w *WhatsApp) Close() error {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	if w.container == nil {
		return nil
	}

	err := w.container.Close()
	w.container = nil

	return err
}

func (w *WhatsApp) sessionPath() string {
	return filepath.Join(w.dir, whatsappSessionFileName)
}

// openSession opens the session database and its first device. The caller holds
// the mutex, or no other goroutine uses w yet.
func (w *WhatsApp) openSession(ctx context.Context) error {
	address, err := whatsappSessionAddress(w.sessionPath())
	if err != nil {
		return err
	}

	container, err := sqlstore.New(ctx, "sqlite", address, waLog.Noop)
	if err != nil {
		return fmt.Errorf("open WhatsApp session: %w", err)
	}

	device, err := container.GetFirstDevice(ctx)
	if err != nil {
		return errors.Join(fmt.Errorf("read WhatsApp device: %w", err), container.Close())
	}

	w.container = container
	w.device = device

	return nil
}

func (w *WhatsApp) isLinked() bool {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	return w.linked
}

// connect makes the client of the linked device and connects it.
func (w *WhatsApp) connect(ctx context.Context) {
	w.mutex.Lock()
	w.client = w.newClient(w.device, w.handle)
	client := w.client
	w.mutex.Unlock()

	err := client.ConnectContext(ctx)
	if err != nil {
		w.logger.Printf("connect: %s", w.redact(err.Error()))
	}
}

// close ends the connection and the timer of the notice, and stops all notices.
func (w *WhatsApp) close() {
	w.mutex.Lock()
	w.closed = true
	if w.timer != nil {
		w.timer.Stop()
	}

	if w.catchupTimer != nil {
		w.catchupTimer.Stop()
	}

	client := w.client
	w.client = nil
	w.mutex.Unlock()

	if client != nil {
		client.Disconnect()
	}
}

// loggedOut logs the open batches, deletes the session after a logout from the
// phone, notes it in the log of l, and tells all clients one time.
func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
	if !w.isLinked() {
		return nil
	}

	err := w.deliver(ctx, l, true)
	if err != nil {
		return err
	}

	err = w.removeSession()
	if err != nil {
		w.logger.Printf("delete the session after the logout: %v", err)
	}

	err = l.note("WhatsApp was unlinked from the phone.")
	if err != nil {
		w.logger.Printf("note the logout: %v", err)
	}

	w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")

	return nil
}

// unlink logs the open batches, logs out the linked device, and deletes the
// session. When the logout call fails, as it does while WhatsApp is
// disconnected, the session is deleted all the same, and answer tells the user
// to remove the device in the phone. Its error is one of the log or the state
// file.
func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) error {
	w.mutex.Lock()
	linked := w.linked
	client := w.client
	w.mutex.Unlock()

	if !linked {
		answer("WhatsApp is not linked.")
		return nil
	}

	err := w.deliver(ctx, l, true)
	if err != nil {
		return err
	}

	var logoutErr error
	if client != nil {
		ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
		defer cancel()

		logoutErr = client.Logout(ctx)
	}

	err = w.removeSession()
	if err != nil {
		answer("The unlink failed: " + w.redact(err.Error()))
		return nil
	}

	err = l.note("WhatsApp is unlinked.")
	if err != nil {
		w.logger.Printf("note the unlink: %v", err)
	}

	if client == nil || logoutErr != nil {
		answer("WhatsApp is unlinked here, but the phone did not get the logout. In WhatsApp on your phone, open Linked devices and remove the device.")
		return nil
	}

	answer("WhatsApp is unlinked.")

	return nil
}

// deliver logs the closed batches in l in order, each as a work message of
// whatsappSource, and wakes the loop once with the batches that start a turn. A
// batch leaves the state file after its message is durable in the log. A group
// with no name gets its name from WhatsApp first. During a catch-up it logs
// nothing, and at its end it closes all batches first. With all, it closes and
// logs all batches also during a catch-up.
func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error {
	w.mutex.Lock()
	catchingUp := w.catchingUp
	caughtUp := w.caughtUp
	w.caughtUp = false
	w.mutex.Unlock()

	var err error
	switch {
	case all || caughtUp:
		err = w.batches.CloseAll()
	case catchingUp:
		return nil
	default:
		_, err = w.batches.CloseDue(time.Now())
	}

	if err != nil {
		return err
	}

	var turns []Message
	for _, batch := range w.batches.Closed() {
		if batch.Chat.Group && batch.Chat.Name == "" {
			batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
		}

		message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")
		if err != nil {
			return fmt.Errorf("log a WhatsApp batch: %w", err)
		}

		// A stop of the daemon during the flush is no failure: the
		// batch stays in the state file and repeats once at the next
		// start.
		err = l.Flush(ctx)
		if ctx.Err() != nil {
			return nil
		}

		if err != nil {
			return fmt.Errorf("log a WhatsApp batch: %w", err)
		}

		err = w.batches.Remove(batch.Number)
		if err != nil {
			return err
		}

		if batch.Turn() {
			turns = append(turns, message)
		}
	}

	l.Wake(turns...)

	return nil
}

// groupName returns the name of the group id, or whatsappUnknownGroup. A group
// that is not in the names of the groups reads the groups from WhatsApp again,
// at most once in whatsappGroupsRefresh.
func (w *WhatsApp) groupName(ctx context.Context, id string) string {
	w.mutex.Lock()
	name, found := w.groupNames[id]
	client := w.client
	fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
	w.mutex.Unlock()

	if found {
		return name
	}

	if client == nil || fresh {
		return whatsappUnknownGroup
	}

	ctx, cancel := context.WithTimeout(ctx, whatsappLookupTime)
	defer cancel()

	groups, err := client.GetJoinedGroups(ctx)
	if err != nil {
		w.logger.Printf("read the groups: %s", w.redact(err.Error()))
	}

	w.mutex.Lock()
	defer w.mutex.Unlock()

	w.groupsAt = time.Now()
	for _, group := range groups {
		w.groupNames[group.JID.String()] = group.Name
	}

	name, found = w.groupNames[id]
	if !found || name == "" {
		return whatsappUnknownGroup
	}

	return name
}

// removeSession ends the connection, closes the session database, and deletes
// its files.
func (w *WhatsApp) removeSession() error {
	w.mutex.Lock()
	client := w.client
	w.client = nil
	w.linked = false
	w.own = nil
	w.connected = false
	w.catchingUp = false
	if w.timer != nil {
		w.timer.Stop()
	}

	w.noticed = false
	container := w.container
	w.container = nil
	w.device = nil
	w.mutex.Unlock()

	if client != nil {
		client.Disconnect()
	}

	var err error
	if container != nil {
		err = container.Close()
	}

	for _, suffix := range []string{"", "-wal", "-shm"} {
		removeErr := os.Remove(w.sessionPath() + suffix)
		if !errors.Is(removeErr, os.ErrNotExist) {
			err = errors.Join(err, removeErr)
		}
	}

	return err
}

// pair links a new device to the account of phone with a pairing code. It gives
// the steps and the code to answer, and then the end of the pairing: the linked
// number, an expired code, or a failure. A pairing that a new one ends gives no
// answer. A link notes "WhatsApp is linked." in the log of l, with no number.
// The client of a pairing that does not link is disconnected.
func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer func(text string)) {
	device, err := w.newDevice(ctx)
	if err != nil {
		answer("The pairing failed: " + err.Error())
		return
	}

	client := w.newClient(device, w.handle)
	linked := false
	defer func() {
		if !linked {
			client.Disconnect()
		}
	}()

	qr, err := client.GetQRChannel(ctx)
	if err == nil {
		err = client.ConnectContext(ctx)
	}

	if err != nil {
		answer("The connection to WhatsApp failed: " + err.Error())
		return
	}

	select {
	case item, open := <-qr:
		if !open || item.Event != whatsmeow.QRChannelEventCode {
			answer("WhatsApp did not start the pairing. Try again later.")
			return
		}
	case <-ctx.Done():
		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
			answer("The connection to WhatsApp did not start the pairing in time. Try again later.")
		}

		return
	}

	code, err := client.PairPhone(ctx, phone, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
	if err != nil {
		answer("WhatsApp refused the pairing: " + err.Error() + ". Check the phone number and run /whatsapp pair PHONE again.")
		return
	}

	answer(whatsappPairSteps)
	answer(code)

	for {
		var item whatsmeow.QRChannelItem
		open := true
		select {
		case item, open = <-qr:
		case <-ctx.Done():
			if errors.Is(ctx.Err(), context.DeadlineExceeded) {
				answer(whatsappPairExpired)
			}

			return
		}

		switch {
		case !open || item.Event == whatsmeow.QRChannelTimeout.Event:
			answer(whatsappPairExpired)
			return
		case item.Event == whatsmeow.QRChannelEventCode:
			continue
		case item.Event == whatsmeow.QRChannelSuccess.Event:
			linked = true
			w.linkedBy(client)

			err = l.note("WhatsApp is linked.")
			if err != nil {
				w.logger.Printf("note the link: %v", err)
			}

			answer("WhatsApp is linked to +" + phone + ".")

			return
		default:
			answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.")
			return
		}
	}
}

// newDevice returns a new device in the session database. It makes the
// directory and the file of the session first, with their modes, when they do
// not exist.
func (w *WhatsApp) newDevice(ctx context.Context) (*store.Device, error) {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	if w.container == nil {
		err := os.MkdirAll(w.dir, 0o700)
		if err != nil {
			return nil, fmt.Errorf("create WhatsApp directory: %w", err)
		}

		file, err := os.OpenFile(w.sessionPath(), os.O_CREATE|os.O_RDWR, 0o600)
		if err != nil {
			return nil, fmt.Errorf("create WhatsApp session: %w", err)
		}

		err = file.Close()
		if err != nil {
			return nil, fmt.Errorf("create WhatsApp session: %w", err)
		}

		err = w.openSession(ctx)
		if err != nil {
			return nil, err
		}
	}

	w.device = w.container.NewDevice()

	return w.device, nil
}

// linkedBy makes client the client of the linked device.
func (w *WhatsApp) linkedBy(client WhatsAppClient) {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	w.client = client
	w.linked = true
}

// handle takes one event of the library and tells if it was handled. A message
// goes to receive. The names of the groups follow the events of the groups. A
// connection starts a catch-up, which ends at OfflineSyncCompleted or after
// catchupLimit. A disconnection keeps the time of its start while the library
// tries again. After noticeDelay of a disconnection, all clients get one
// notice, and they get one more when the connection comes back. A disconnection
// that the library does not try again gives a notice at once.
func (w *WhatsApp) handle(event any) bool {
	message, isMessage := event.(*events.Message)
	if isMessage {
		return w.receive(message)
	}

	var notice string
	w.mutex.Lock()
	switch event := event.(type) {
	case *events.GroupInfo:
		if event.Name != nil {
			w.groupNames[event.JID.String()] = event.Name.Name
		}
	case *events.JoinedGroup:
		w.groupNames[event.JID.String()] = event.Name
	case *events.PairSuccess:
		w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
	case *events.Connected:
		w.connected = true
		w.connectedAt = w.clock()
		w.catchingUp = true
		w.catchups++
		catchups := w.catchups
		if w.catchupTimer != nil {
			w.catchupTimer.Stop()
		}

		w.catchupTimer = time.AfterFunc(w.catchupLimit, func() {
			w.caughtUpBy(catchups)
		})
		if w.timer != nil {
			w.timer.Stop()
		}

		if w.noticed {
			w.noticed = false
			notice = "WhatsApp is connected again."
		}
	case *events.Disconnected:
		if w.linked && (w.connected || w.disconnectedAt.IsZero()) {
			w.disconnectedAt = w.clock()
			w.disconnections++
			disconnections := w.disconnections
			w.timer = time.AfterFunc(w.noticeDelay, func() {
				w.disconnectedLong(disconnections)
			})
		}

		w.connected = false
	case *events.OfflineSyncCompleted:
		w.endCatchup()
	case *events.LoggedOut:
		select {
		case w.logouts <- struct{}{}:
		default:
		}
	case events.PermanentDisconnect:
		if w.linked {
			w.connected = false
			w.noticed = true
			notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again."
		}
	}
	w.mutex.Unlock()

	if notice != "" {
		w.broadcast(notice)
	}

	return true
}

// receive puts the text of event into its batch and wakes Run. It returns false
// when the state file cannot hold the message, so that the library does not
// acknowledge it, and Run stops the daemon. A message that is not text, or that
// the batches do not take, is handled with nothing to do.
func (w *WhatsApp) receive(event *events.Message) bool {
	ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
	defer cancel()

	chat, message, found := w.message(ctx, event)
	if !found {
		return true
	}

	_, err := w.batches.Add(chat, message, time.Now())
	if err != nil {
		select {
		case w.failures <- err:
		default:
		}

		return false
	}

	select {
	case w.wake <- struct{}{}:
	default:
	}

	return true
}

// message returns the chat and the batch message of event, or false when the
// batches do not take it. They take the text of a private chat or a group, from
// another person or from the user. They do not take media, reactions, edits,
// deletions, view-once and disappearing messages, old history, status
// broadcasts, channels, and the chat of the user with itself.
//
// A mention of the user becomes @you, another mention @NAME when the name is
// known, and the own number and LID become OWN, so that they never go to the
// log.
func (w *WhatsApp) message(ctx context.Context, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
	w.mutex.Lock()
	device := w.device
	own := slices.Clone(w.own)
	w.mutex.Unlock()

	info := event.Info
	chatJID := info.Chat.ToNonAD()
	switch {
	case device == nil:
	case event.IsEdit, info.Edit != "", event.IsEphemeral, event.IsViewOnce, event.SourceWebMsg != nil:
	case chatJID.Server != types.DefaultUserServer && chatJID.Server != types.HiddenUserServer && chatJID.Server != types.GroupServer:
	case slices.Contains(own, chatJID.User):
	default:
		return w.text(ctx, device, own, event)
	}

	return WhatsAppChat{}, WhatsAppMessage{}, false
}

// text returns the chat and the batch message of event, a message that the
// batches take when it has text.
func (w *WhatsApp) text(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
	info := event.Info
	text := event.Message.GetConversation()
	extended := event.Message.GetExtendedTextMessage()
	if text == "" {
		text = extended.GetText()
	}

	if strings.TrimSpace(text) == "" {
		return WhatsAppChat{}, WhatsAppMessage{}, false
	}

	contextInfo := extended.GetContextInfo()
	message := WhatsAppMessage{
		ID:   info.ID,
		Time: info.Timestamp,
		Mine: info.IsFromMe,
	}

	if !message.Mine {
		message.Sender = whatsappContactName(ctx, device, info.Sender, info.PushName)
	}

	for _, mentioned := range contextInfo.GetMentionedJID() {
		jid, err := types.ParseJID(mentioned)
		switch {
		case err != nil:
		case slices.Contains(own, jid.User):
			message.Mention = true
			text = strings.ReplaceAll(text, "@"+jid.User, "@you")
		default:
			text = strings.ReplaceAll(text, "@"+jid.User, "@"+whatsappContactName(ctx, device, jid, ""))
		}
	}

	participant, err := types.ParseJID(contextInfo.GetParticipant())
	message.Reply = err == nil && slices.Contains(own, participant.User)

	for _, id := range own {
		text = strings.ReplaceAll(text, id, "OWN")
	}

	message.Text = text
	chatJID := info.Chat.ToNonAD()
	chat := WhatsAppChat{
		ID:    chatJID.String(),
		Group: chatJID.Server == types.GroupServer,
	}

	if !chat.Group {
		push := info.PushName
		if message.Mine {
			push = ""
		}

		chat.Name = whatsappContactName(ctx, device, chatJID, push)
	}

	return chat, message, true
}

// caughtUpBy ends the catch-up of the connection with the number catchups, when
// no later connection started a new one.
func (w *WhatsApp) caughtUpBy(catchups int) {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	if w.catchups == catchups {
		w.endCatchup()
	}
}

// endCatchup ends a running catch-up and wakes Run, which logs all batches. The
// caller holds the mutex.
func (w *WhatsApp) endCatchup() {
	if !w.catchingUp {
		return
	}

	w.catchingUp = false
	w.caughtUp = true
	if w.catchupTimer != nil {
		w.catchupTimer.Stop()
	}

	select {
	case w.wake <- struct{}{}:
	default:
	}
}

// disconnectedLong gives the notice of a long disconnection, unless the
// disconnection with the number disconnections ended.
func (w *WhatsApp) disconnectedLong(disconnections int) {
	w.mutex.Lock()
	long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections
	if long {
		w.noticed = true
	}

	since := w.disconnectedAt
	w.mutex.Unlock()

	if long {
		w.broadcast("WhatsApp is disconnected since " + since.Format(whatsappTimeLayout) + ". OneChat tries again.")
	}
}

// broadcast gives text as a notice to all clients.
func (w *WhatsApp) broadcast(text string) {
	w.mutex.Lock()
	notify := w.notify
	closed := w.closed
	w.mutex.Unlock()

	if notify != nil && !closed {
		notify(Event{
			Kind: "notice",
			Text: text,
		})
	}
}

// redact replaces the own number and the own LID in text with OWN.
func (w *WhatsApp) redact(text string) string {
	w.mutex.Lock()
	defer w.mutex.Unlock()

	for _, id := range w.own {
		text = strings.ReplaceAll(text, id, "OWN")
	}

	return text
}

// WhatsAppRequest is a pair or unlink command for Run, with the function that
// gives its answers to the client that asked. A pairing has the phone number.
type WhatsAppRequest struct {
	phone  string
	unlink bool
	answer func(text string)
}

// whatsappNewClient returns the client of the library for device, with handle
// as its event handler. The client tries again after a failed first connection,
// acknowledges a message only after handle returns true, and downloads no old
// history. The phone shows the device with the name OneChat.
func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
	store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
	client := whatsmeow.NewClient(device, waLog.Noop)
	client.InitialAutoReconnect = true
	client.SynchronousAck = true
	client.ManualHistorySyncDownload = true
	client.AddEventHandlerWithSuccessStatus(handle)

	return client
}

// whatsappContactName returns the name of the person jid: the full name, the
// first name, the business name, or the push name of the contact in the session
// of device, then push, the push name of a message, then the phone number. A
// LID gets its phone number from the LID map of the session.
func whatsappContactName(ctx context.Context, device *store.Device, jid types.JID, push string) string {
	jid = jid.ToNonAD()
	candidates := []types.JID{jid}
	phone := types.EmptyJID
	switch jid.Server {
	case types.DefaultUserServer:
		phone = jid
	case types.HiddenUserServer:
		mapped, err := device.LIDs.GetPNForLID(ctx, jid)
		if err == nil && !mapped.IsEmpty() {
			phone = mapped
			candidates = append(candidates, mapped)
		}
	}

	for _, candidate := range candidates {
		contact, err := device.Contacts.GetContact(ctx, candidate)
		if err != nil || !contact.Found {
			continue
		}

		for _, name := range []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName} {
			if name != "" {
				return name
			}
		}
	}

	switch {
	case push != "":
		return push
	case !phone.IsEmpty():
		return "+" + phone.User
	default:
		return jid.User
	}
}

// whatsappOwnIDs returns the own number and the own LID that are not empty.
func whatsappOwnIDs(ids ...string) []string {
	var own []string
	for _, id := range ids {
		if id != "" {
			own = append(own, id)
		}
	}

	return own
}

// whatsappSessionAddress returns the SQLite address of the session database at
// path, with foreign keys on, as the library needs, and a wait for a busy
// database.
func whatsappSessionAddress(path string) (string, error) {
	path, err := filepath.Abs(path)
	if err != nil {
		return "", fmt.Errorf("find WhatsApp session: %w", err)
	}

	address := url.URL{
		Scheme:   "file",
		Path:     path,
		RawQuery: "_pragma=foreign_keys(1)&_pragma=busy_timeout(5000)",
	}

	return address.String(), nil
}

// whatsappCommandArgs returns the text after /whatsapp of a line of a WhatsApp
// command, or false for any other line.
func whatsappCommandArgs(line string) (string, bool) {
	line = strings.TrimSpace(line)
	if line == whatsappCommand {
		return "", true
	}

	args, found := strings.CutPrefix(line, whatsappCommand+" ")
	if !found {
		return "", false
	}

	return strings.TrimSpace(args), true
}

// whatsappPhone returns the digits of phone, a number with its country code and
// an optional + and dashes, and tells if it has the form of a number: 7 to 15
// digits, with no 0 first.
func whatsappPhone(phone string) (string, bool) {
	phone = strings.ReplaceAll(strings.TrimPrefix(phone, "+"), "-", "")
	valid := len(phone) >= 7 && len(phone) <= 15 && phone[0] != '0' && strings.Trim(phone, "0123456789") == ""

	return phone, valid
}

// whatsappItemError returns the error of a pairing item that is not a code, a
// success, or a timeout.
func whatsappItemError(item whatsmeow.QRChannelItem) string {
	if item.Error != nil {
		return item.Error.Error()
	}

	return item.Event
}