// Package repl implements the main event loop.
package repl

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"git.lyda.ie/kevin/bulletin/ask"
	"git.lyda.ie/kevin/bulletin/dclish"
	"git.lyda.ie/kevin/bulletin/editor"
	"git.lyda.ie/kevin/bulletin/folders"
	"git.lyda.ie/kevin/bulletin/pager"
	"git.lyda.ie/kevin/bulletin/storage"
	"git.lyda.ie/kevin/bulletin/this"
)

// ActionDirectory handles the `DIRECTORY` command.  This lists all the
// messages in the current folder.
func ActionDirectory(cmd *dclish.Command) error {
	// TODO: flag parsing.
	showExpiration := false
	if cmd.Flags["/EXPIRATION"].Value == "true" {
		showExpiration = true
	}
	if len(cmd.Args) == 1 {
		folder, err := folders.ValidFolder(cmd.Args[0])
		if err != nil {
			fmt.Println("Folder does not exist.")
			return nil
		}
		if !folders.IsFolderAccess(folder.Name, this.User.Login) {
			fmt.Println("No permission to access folder.")
			return nil
		}
		this.Folder = folder
		this.ReadFirstCall = true
	}
	msgs, err := folders.ListMessages(this.Folder.Name)
	if err != nil {
		return err
	}
	if len(msgs) == 0 {
		fmt.Println("There are no messages present.")
		return nil
	}
	buf := strings.Builder{}
	buf.WriteString(fmt.Sprintf("%4s %-43s %-12s %-10s\n", "#", "Subject", "From", "Date"))
	for _, msg := range msgs {
		buf.WriteString(fmt.Sprint(msg.OneLine(showExpiration)))
	}
	pager.Pager(buf.String())

	return nil
}

// ActionAdd handles the `ADD` command.  This adds a message to a folder.
func ActionAdd(cmd *dclish.Command) error {
	optAll := 0
	optBell := 0
	optBroadcast := 0
	optEdit := 0
	optExpiration := &time.Time{}
	optExtract := 0
	optFolder := []string{}
	optIndent := 0
	optPermanent := 0
	optShutdown := 0
	optSignature := 0
	optSubject := ""
	optSystem := 0

	if cmd.Flags["/ALL"].Value == "true" {
		optAll = 1
	}
	if cmd.Flags["/BELL"].Value == "true" {
		optBell = 1
	}
	if cmd.Flags["/BROADCAST"].Value == "true" {
		optBroadcast = 1
	}
	if cmd.Flags["/EDIT"].Value == "true" {
		optEdit = 1
	}
	if cmd.Flags["/EXPIRATION"].Value != "" {
		// dd-mmm-yyyy, or delta time: dddd
		exp, err := time.Parse("2006-01-02", cmd.Flags["/EXPIRATION"].Value)
		if err != nil {
			days, err := strconv.Atoi(cmd.Flags["/EXPIRATION"].Value)
			if err != nil {
				optExpiration = nil
			}
			exp := time.Now().AddDate(0, 0, days)
			optExpiration = &exp
		} else {
			optExpiration = &exp
		}
	}
	if cmd.Flags["/EXTRACT"].Value == "true" {
		optExtract = 1
	}
	if cmd.Flags["/FOLDER"].Value != "" {
		optFolder = strings.Split(cmd.Flags["/FOLDER"].Value, ",")
	}
	if cmd.Flags["/INDENT"].Value == "true" {
		optIndent = 1
	}
	if cmd.Flags["/PERMANENT"].Value == "true" {
		optPermanent = 1
	}
	if cmd.Flags["/SHUTDOWN"].Value == "true" {
		optShutdown = 1
	}
	if cmd.Flags["/SIGNATURE"].Value == "true" {
		optSignature = 1
	}
	if cmd.Flags["/SUBJECT"].Value != "" {
		optSubject = cmd.Flags["/SUBJECT"].Value
	}
	if cmd.Flags["/SYSTEM"].Value == "true" {
		optSystem = 1
	}

	fmt.Printf("TODO: optAll is not yet implemented - you set it to %d\n", optAll)
	fmt.Printf("TODO: optBell is not yet implemented - you set it to %d\n", optBell)
	fmt.Printf("TODO: optBroadcast is not yet implemented - you set it to %d\n", optBroadcast)
	fmt.Printf("TODO: optEdit is not yet implemented - you set it to %d\n", optEdit)
	fmt.Printf("TODO: optExtract is not yet implemented - you set it to %d\n", optExtract)
	fmt.Printf("TODO: optIndent is not yet implemented - you set it to %d\n", optIndent)
	fmt.Printf("TODO: optSignature is not yet implemented - you set it to %d\n", optSignature)
	fmt.Printf("TODO: optSystem is not yet implemented - you set it to %d\n", optSystem)

	if len(optFolder) == 0 {
		optFolder = []string{this.Folder.Name}
	}
	// TODO: check if folders exist.
	if optSubject == "" {
		optSubject, _ = ask.GetLine("Enter subject of message: ")
		if optSubject == "" {
			return errors.New("Must enter a subject")
		}
	}
	// TODO: check we have permission for shutdown and permanent

	message, err := editor.Editor(
		fmt.Sprintf("Enter message for '%s'...", optSubject),
		"Edit message",
		"")
	if err != nil {
		return err
	}
	for i := range optFolder {
		err = folders.CreateMessage(this.User.Login, optSubject, message,
			optFolder[i], optPermanent, optShutdown, optExpiration)
	}
	return nil
}

// ActionCurrent handles the `CURRENT` command.
func ActionCurrent(_ *dclish.Command) error {
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, this.MsgID)
	if err != nil {
		return err
	}
	lines := strings.Split(msg.String(), "\n")
	if len(lines) > 10 {
		lines = lines[:10]
	}
	fmt.Printf("%s\n", strings.Join(lines, "\n"))
	return nil
}

// ActionBack handles the `BACK` command.
func ActionBack(_ *dclish.Command) error {
	msgid := folders.PrevMsgid(this.User.Login, this.Folder.Name, this.MsgID)
	if msgid == 0 {
		fmt.Println("No previous messages")
		return nil
	}
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
	if err != nil {
		return err
	}
	if pager.Pager(msg.String()) {
		this.MsgID = msgid
		folders.MarkSeen([]int64{msgid})
	}
	return nil
}

// ActionChange handles the `CHANGE` command.  This replaces or modifies
// an existing message.
func ActionChange(cmd *dclish.Command) error {
	var err error
	optAll := false
	if cmd.Flags["/ALL"].Value == "true" {
		optAll = true
	}

	optExpiration := &time.Time{}
	if cmd.Flags["/EXPIRATION"].Value != "" {
		// dd-mmm-yyyy, or delta time: dddd
		exp, err := time.Parse("2006-01-02", cmd.Flags["/EXPIRATION"].Value)
		if err != nil {
			days, err := strconv.Atoi(cmd.Flags["/EXPIRATION"].Value)
			if err != nil {
				optExpiration = nil
			}
			exp := time.Now().AddDate(0, 0, days)
			optExpiration = &exp
		} else {
			optExpiration = &exp
		}
	}

	optGeneral := false
	if cmd.Flags["/GENERAL"].Set && this.Folder.Name != "GENERAL" {
		return errors.New("Can only be used in the GENERAL folder")
	}
	if cmd.Flags["/GENERAL"].Value == "true" {
		optGeneral = true
	}
	if cmd.Flags["/GENERAL"].Set && !optGeneral {
		return errors.New("Can't specify /NOGENERAL - see /SYSTEM")
	}

	optNew := false
	if cmd.Flags["/NEW"].Value == "true" {
		optNew = true
	}

	optNumber := []int64{this.MsgID}
	if cmd.Flags["/NUMBER"].Set && cmd.Flags["/NUMBER"].Value == "" {
		return errors.New("Must supply message number(s) if /NUMBER is set")
	}
	if cmd.Flags["/NUMBER"].Value != "" {
		optNumber, err = ParseNumberList(cmd.Flags["/NUMBER"].Value)
		if err != nil {
			return err
		}
	}

	optPermanent := false
	if cmd.Flags["/PERMANENT"].Value == "true" {
		optPermanent = true
	}

	optShutdown := false
	if cmd.Flags["/SHUTDOWN"].Value == "true" {
		optShutdown = true
	}

	optSubject := ""
	if cmd.Flags["/SUBJECT"].Set && cmd.Flags["/SUBJECT"].Value == "" {
		return errors.New("Must supply subject text if /SUBJECT is set")
	}
	if cmd.Flags["/SUBJECT"].Value != "" {
		optSubject = cmd.Flags["/SUBJECT"].Value
	}

	optSystem := false
	if cmd.Flags["/SYSTEM"].Set {
		if this.User.Admin == 0 {
			return errors.New("Must be admin")
		}
		if this.Folder.Name != "GENERAL" {
			return errors.New("Can only be used in the GENERAL folder")
		}
	}
	if cmd.Flags["/SYSTEM"].Value == "true" {
		optSystem = true
	}
	if cmd.Flags["/SYSTEM"].Set && !optSystem {
		return errors.New("Can't specify /NOSYSTEM - see /GENERAL")
	}

	optText := false
	if cmd.Flags["/TEXT"].Value == "true" {
		optText = true
	}

	// Sanity checking.
	if optSystem && optGeneral {
		return errors.New("Can't specify /SYSTEM and /GENERAL")
	}

	fmt.Println("TODO: flags parsed, now need to do something.")
	return nil
}

// ActionFirst handles the `FIRST` command.
func ActionFirst(_ *dclish.Command) error {
	msgid := folders.FirstMessage(this.Folder.Name)
	if msgid == 0 {
		fmt.Println("No messages in folder")
		return nil
	}
	this.MsgID = msgid
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
	if err != nil {
		return err
	}
	if pager.Pager(msg.String()) {
		folders.MarkSeen([]int64{msgid})
	}
	return nil
}

// ActionLast handles the `LAST` command.
func ActionLast(_ *dclish.Command) error {
	msgid := folders.LastMessage(this.Folder.Name)
	if msgid == 0 {
		fmt.Println("No messages in folder")
		return nil
	}
	this.MsgID = msgid
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
	if err != nil {
		return err
	}
	if pager.Pager(msg.String()) {
		folders.MarkSeen([]int64{msgid})
	}
	return nil
}

// ActionNext handles the `NEXT` command.
func ActionNext(_ *dclish.Command) error {
	msgid := folders.NextMsgid(this.User.Login, this.Folder.Name, this.MsgID)
	if msgid == 0 {
		fmt.Println("No next messages")
		return nil
	}
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
	if err != nil {
		return err
	}
	pager.Pager(msg.String())
	if pager.Pager(msg.String()) {
		folders.MarkSeen([]int64{msgid})
		this.MsgID = msgid
	}
	return nil
}

// ActionPrint handles the `PRINT` command.
func ActionPrint(cmd *dclish.Command) error {
	all := false
	if cmd.Flags["/ALL"].Value == "true" {
		all = true
	}

	ctx := storage.Context()
	msgids := []int64{this.MsgID}
	var err error
	if len(cmd.Args) == 1 {
		if all {
			return errors.New("Can't provide a message list and /ALL")
		}
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			return err
		}
	} else if all {
		msgids, err = this.Q.ListMessageIDs(ctx, this.Folder.Name)
	}
	print("\033[5i")
	for _, msgid := range msgids {
		msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
		if err != nil {
			fmt.Printf("Message %d not found.\n", msgid)
		} else {
			fmt.Print(msg.String())
		}
		print("\n\v")
	}
	print("\033[4i")
	return nil
}

// ActionRead handles the `READ` command.
func ActionRead(cmd *dclish.Command) error {
	defer func() { this.ReadFirstCall = false }()
	msgid := this.MsgID
	if !this.ReadFirstCall && len(cmd.Args) == 0 {
		msgid = folders.NextMsgid(this.User.Login, this.Folder.Name, msgid)
		if msgid < this.MsgID {
			fmt.Println("No more unread messages.")
			return nil
		}
	} else if len(cmd.Args) == 1 {
		var err error
		msgid, err = strconv.ParseInt(cmd.Args[0], 10, 64)
		if err != nil {
			return err
		}
	}
	this.MsgID = msgid
	msg, err := folders.ReadMessage(this.User.Login, this.Folder.Name, msgid)
	if err != nil {
		return err
	}
	if pager.Pager(msg.String()) {
		folders.MarkSeen([]int64{msgid})
	}
	return nil
}

// ActionReply handles the `REPLY` command.
func ActionReply(cmd *dclish.Command) error {
	extract := true
	if cmd.Flags["/EXTRACT"].Value == "false" {
		extract = false
	}
	indent := true
	if cmd.Flags["/INDENT"].Value == "false" {
		indent = false
	}
	original, err := folders.ReadMessage(this.User.Login, this.Folder.Name, this.MsgID)
	origMsg := ""
	if extract {
		if indent {
			origMsg = "> " + strings.Join(strings.Split(original.Message, "\n"), "\n> ")
		} else {
			origMsg = original.Message
		}
	}

	subject := "Re: " + original.Subject
	message, err := editor.Editor(
		fmt.Sprintf("Enter message for '%s'...", subject),
		"Edit message",
		origMsg)
	if err != nil {
		fmt.Printf("ERROR: Editor failure (%s).\n", err)
		return nil
	}
	err = folders.CreateMessage(this.User.Login, subject,
		message, this.Folder.Name, 0, 0, nil)
	if err != nil {
		fmt.Printf("ERROR: CreateMessage failure (%s).\n", err)
		return nil
	}
	return nil
}

// ActionForward handles the `FORWARD` command.
func ActionForward(cmd *dclish.Command) error {
	fmt.Printf("TODO: unimplemented...\n%s\n", cmd.Description)
	return nil
}

// ActionSeen handles the `SEEN` command.
func ActionSeen(cmd *dclish.Command) error {
	// TODO: review help.
	var err error
	msgids := []int64{this.MsgID}
	if len(cmd.Args) == 1 {
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			return err
		}
	}
	err = folders.MarkSeen(msgids)
	if err != nil {
		fmt.Printf("ERROR: %s.\n", err)
	}
	return nil
}

// ActionUnseen handles the `UNSEEN` command.
func ActionUnseen(cmd *dclish.Command) error {
	// TODO: review help.
	var err error
	msgids := []int64{this.MsgID}
	if len(cmd.Args) == 1 {
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			return err
		}
	}
	err = folders.MarkUnseen(msgids)
	if err != nil {
		fmt.Printf("ERROR: %s.\n", err)
	}
	return nil
}

// ActionDelete handles the `DELETE` command.
func ActionDelete(cmd *dclish.Command) error {
	// TODO: Follow permissions.
	var err error

	all := false
	if cmd.Flags["/ALL"].Value == "true" {
		all = true
	}
	if all {
		if len(cmd.Args) == 1 {
			fmt.Println("ERROR: Can't specify both message numbers and /ALL flag.")
			return nil
		}
		err := folders.DeleteAllMessages()
		if err != nil {
			fmt.Printf("ERROR: %s.\n", err)
		}
		return nil
	}

	msgids := []int64{this.MsgID}
	if len(cmd.Args) == 1 {
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			fmt.Printf("ERROR: %s.\n", err)
			return nil
		}
	}
	err = folders.DeleteMessages(msgids)
	if err != nil {
		fmt.Printf("ERROR: %s.\n", err)
	}
	return nil
}

// ActionMark handles the `MARK` command.
func ActionMark(cmd *dclish.Command) error {
	var err error
	msgids := []int64{this.MsgID}
	if len(cmd.Args) == 1 {
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			return err
		}
	}
	err = folders.SetMark(msgids)
	if err != nil {
		fmt.Printf("ERROR: %s.\n", err)
	}
	return nil
}

// ActionUnmark handles the `UNMARK` command.
func ActionUnmark(cmd *dclish.Command) error {
	var err error
	msgids := []int64{this.MsgID}
	if len(cmd.Args) == 1 {
		msgids, err = ParseNumberList(cmd.Args[0])
		if err != nil {
			return err
		}
	}
	err = folders.UnsetMark(msgids)
	if err != nil {
		fmt.Printf("ERROR: %s.\n", err)
	}
	return nil
}

// ActionSearch handles the `SEARCH` command.  This will show all messages
// matching a search term.
//
// See subtoutines SEARCH and GET_SEARCH in bulletin2.for for the
// original implementation.
func ActionSearch(cmd *dclish.Command) error {
	ctx := storage.Context()
	var err error
	optFolders := []string{this.Folder.Name}
	if cmd.Flags["/FOLDER"].Value != "" {
		optFolders = strings.Split(strings.ToUpper(cmd.Flags["/FOLDER"].Value), ",")
		for i := range optFolders {
			folder, _ := this.Q.FindFolderExact(ctx, optFolders[i])
			if folder.Name != "" {
				return fmt.Errorf("Folder '%s' not found", optFolders[i])
			}
			if folders.IsFolderAccess(optFolders[i], this.User.Login) {
				return fmt.Errorf("Folder '%s' is not accessible", optFolders[i])
			}
		}
	}

	optReply := false
	if cmd.Flags["/REPLY"].Value == "true" {
		optReply = true
	}

	optReverse := false
	if cmd.Flags["/REVERSE"].Value == "true" {
		optReverse = true
	}

	optStart := int64(-1) // -1 means first message.
	if optReverse {
		optStart = 0 // 0 means last message.
	}
	if cmd.Flags["/START"].Set {
		optStart, err = strconv.ParseInt(cmd.Flags["/START"].Value, 10, 64)
		if err != nil {
			return err
		}
		if optStart < 1 {
			return errors.New("/START must be 1 or larger")
		}
	}

	optSubject := false
	if cmd.Flags["/SUBJECT"].Value == "true" {
		optSubject = true
	}

	var searchTerm string
	if optReply {
		if optSubject || len(cmd.Args) == 1 {
			return errors.New("Can't specify /REPLY and a search term or /SUBJECT")
		}
		msg, err := this.Q.ReadMessage(ctx, storage.ReadMessageParams{
			Folder: this.Folder.Name,
			ID:     this.MsgID,
		})
		if err != nil {
			return err
		}
		searchTerm = "Re: " + msg.Subject
	} else {
		searchTerm = cmd.Args[0]
	}

	allMsgs := []storage.Message{}
	msgs := []storage.Message{}
	var start int64
	for i := range optFolders {
		switch optStart {
		case -1:
			start = 1
		case 0:
			start, err := this.Q.LastMsgidIgnoringSeen(ctx, optFolders[i])
			if err != nil || start == 0 {
				continue
			}
		default:
			start = optStart
		}
		if optReply {
			if optReverse {
				msgs, err = this.Q.SearchReplyReverse(ctx,
					storage.SearchReplyReverseParams{
						Subject: searchTerm,
						ID:      start,
						Folder:  optFolders[i],
					})
			} else {
				msgs, err = this.Q.SearchReply(ctx,
					storage.SearchReplyParams{
						Subject: searchTerm,
						ID:      start,
						Folder:  optFolders[i],
					})
			}
		} else if optSubject {
			if optReverse {
				msgs, err = this.Q.SearchSubjectReverse(ctx,
					storage.SearchSubjectReverseParams{
						Column1: nullStr(searchTerm),
						ID:      start,
						Folder:  optFolders[i],
					})
			} else {
				msgs, err = this.Q.SearchSubject(ctx,
					storage.SearchSubjectParams{
						Column1: nullStr(searchTerm),
						ID:      start,
						Folder:  optFolders[i],
					})
			}
		} else {
			if optReverse {
				msgs, err = this.Q.SearchReverse(ctx,
					storage.SearchReverseParams{
						Column1: nullStr(searchTerm),
						ID:      start,
						Folder:  optFolders[i],
					})
			} else {
				msgs, err = this.Q.Search(ctx,
					storage.SearchParams{
						Column1: nullStr(searchTerm),
						ID:      start,
						Folder:  optFolders[i],
					})
			}
		}
		if err != nil {
			continue
		}
		if len(allMsgs)+len(msgs) > 100 {
			fmt.Println("Too many messages match; narrow search term.")
			return nil
		}
		allMsgs = append(allMsgs, msgs...)
	}

	if len(allMsgs) == 0 {
		fmt.Println("No messages found.")
		return nil
	}
	buf := strings.Builder{}
	for _, msg := range allMsgs {
		buf.WriteString(msg.String())
		buf.WriteString("\n\n")
	}
	pager.Pager(buf.String())

	return nil
}