package msg

import (
	"bytes"
	"fmt"
	"time"

	"git.sr.ht/~rjarry/aerc/app"
	"git.sr.ht/~rjarry/aerc/commands"
	"git.sr.ht/~rjarry/aerc/lib"
	cryptoutil "git.sr.ht/~rjarry/aerc/lib/crypto/util"
	"git.sr.ht/~rjarry/aerc/lib/log"
	"git.sr.ht/~rjarry/aerc/models"
	"git.sr.ht/~rjarry/aerc/worker/types"
	"github.com/emersion/go-message/mail"
	"github.com/pkg/errors"
)

type Copy struct {
	CreateFolders     bool                     `opt:"-p"`
	Decrypt           bool                     `opt:"-d"`
	Account           string                   `opt:"-a" complete:"CompleteAccount"`
	MultiFileStrategy *types.MultiFileStrategy `opt:"-m" action:"ParseMFS" complete:"CompleteMFS"`
	Folder            string                   `opt:"folder" complete:"CompleteFolder"`
}

func init() {
	commands.Register(Copy{})
}

func (Copy) Context() commands.CommandContext {
	return commands.MESSAGE_LIST | commands.MESSAGE_VIEWER
}

func (Copy) Aliases() []string {
	return []string{"cp", "copy"}
}

func (c *Copy) ParseMFS(arg string) error {
	if arg != "" {
		mfs, ok := types.StrToStrategy[arg]
		if !ok {
			return fmt.Errorf("invalid multi-file strategy %s", arg)
		}
		c.MultiFileStrategy = &mfs
	}
	return nil
}

func (*Copy) CompleteAccount(arg string) []string {
	return commands.FilterList(app.AccountNames(), arg, commands.QuoteSpace)
}

func (c *Copy) CompleteFolder(arg string) []string {
	var acct *app.AccountView
	if len(c.Account) > 0 {
		acct, _ = app.Account(c.Account)
	} else {
		acct = app.SelectedAccount()
	}
	if acct == nil {
		return nil
	}
	return commands.FilterList(acct.Directories().List(), arg, nil)
}

func (Copy) CompleteMFS(arg string) []string {
	return commands.FilterList(types.StrategyStrs(), arg, nil)
}

func (c Copy) Execute(args []string) error {
	h := newHelper()
	uids, err := h.markedOrSelectedUids()
	if err != nil {
		return err
	}
	store, err := h.store()
	if err != nil {
		return err
	}

	// when the decrypt flag is set, add the current account to c.Account to
	// ensure that we do not take the store.Copy route.
	if c.Decrypt {
		if acct := app.SelectedAccount(); acct != nil {
			c.Account = acct.Name()
		} else {
			return errors.New("no account name found")
		}
	}

	if len(c.Account) == 0 {
		store.Copy(uids, c.Folder, c.CreateFolders, c.MultiFileStrategy,
			func(msg types.WorkerMessage) {
				c.CallBack(msg, uids, store)
			})
		return nil
	}

	destAcct, err := app.Account(c.Account)
	if err != nil {
		return err
	}

	destStore := destAcct.Store()
	if destStore == nil {
		app.PushError(fmt.Sprintf("No message store in %s", c.Account))
		return nil
	}

	var messages []*types.FullMessage
	fetchDone := make(chan bool, 1)
	store.FetchFull(uids, func(fm *types.FullMessage) {
		if fm == nil {
			return
		}

		if c.Decrypt {
			h := new(mail.Header)
			msg, ok := store.Messages[fm.Content.Uid]
			if ok {
				h = msg.RFC822Headers
			}
			cleartext, err := cryptoutil.Cleartext(fm.Content.Reader, *h)
			if err != nil {
				log.Debugf("could not decrypt message %v", fm.Content.Uid)
			} else {
				fm.Content.Reader = bytes.NewReader(cleartext)
			}
		}

		messages = append(messages, fm)
		if len(messages) == len(uids) {
			fetchDone <- true
		}
	})

	// Since this operation can take some time with some backends
	// (e.g. IMAP), provide some feedback to inform the user that
	// something is happening
	app.PushStatus("Copying messages...", 10*time.Second)
	go func() {
		defer log.PanicHandler()

		select {
		case <-fetchDone:
			break
		case <-time.After(30 * time.Second):
			// TODO: find a better way to determine if store.FetchFull()
			// has finished with some errors.
			app.PushError("Failed to fetch all messages")
			if len(messages) == 0 {
				return
			}
		}
		for _, fm := range messages {
			buf := new(bytes.Buffer)
			_, err = buf.ReadFrom(fm.Content.Reader)
			if err != nil {
				log.Warnf("failed to read message: %v", err)
				continue
			}
			destStore.Append(
				c.Folder,
				models.SeenFlag,
				time.Now(),
				buf,
				buf.Len(),
				func(msg types.WorkerMessage) {
					c.CallBack(msg, uids, store)
				},
			)
		}
	}()
	return nil
}

func (c Copy) CallBack(msg types.WorkerMessage, uids []models.UID, store *lib.MessageStore) {
	dest := c.Folder
	if len(c.Account) != 0 {
		dest = fmt.Sprintf("%s in %s", c.Folder, c.Account)
	}

	switch msg := msg.(type) {
	case *types.Done:
		var s string
		if len(uids) > 1 {
			s = "%d messages copied to %s"
		} else {
			s = "%d message copied to %s"
		}
		app.PushStatus(fmt.Sprintf(s, len(uids), dest), 10*time.Second)
		store.Marker().ClearVisualMark()
	case *types.Error:
		app.PushError(msg.Error.Error())
	}
}