package modify

import (
	"context"
	"fmt"
	"strings"

	"github.com/emersion/go-message/textproto"
	"github.com/foxcpp/maddy/internal/address"
	"github.com/foxcpp/maddy/internal/buffer"
	"github.com/foxcpp/maddy/internal/config"
	modconfig "github.com/foxcpp/maddy/internal/config/module"
	"github.com/foxcpp/maddy/internal/module"
)

// replaceAddr is a simple module that replaces matching sender (or recipient) address
// in messages using module.Table implementation.
//
// If created with modName = "replace_sender", it will change sender address.
// If created with modName = "replace_rcpt", it will change recipient addresses.
type replaceAddr struct {
	modName    string
	instName   string
	inlineArgs []string

	replaceSender bool
	replaceRcpt   bool
	table         module.Table
}

func NewReplaceAddr(modName, instName string, _, inlineArgs []string) (module.Module, error) {
	r := replaceAddr{
		modName:       modName,
		instName:      instName,
		inlineArgs:    inlineArgs,
		replaceSender: modName == "replace_sender",
		replaceRcpt:   modName == "replace_rcpt",
	}

	return &r, nil
}

func (r *replaceAddr) Init(cfg *config.Map) error {
	return modconfig.ModuleFromNode(r.inlineArgs, cfg.Block, cfg.Globals, &r.table)
}

func (r replaceAddr) Name() string {
	return r.modName
}

func (r replaceAddr) InstanceName() string {
	return r.instName
}

func (r replaceAddr) ModStateForMsg(ctx context.Context, msgMeta *module.MsgMetadata) (module.ModifierState, error) {
	return r, nil
}

func (r replaceAddr) RewriteSender(ctx context.Context, mailFrom string) (string, error) {
	if r.replaceSender {
		return r.rewrite(mailFrom)
	}
	return mailFrom, nil
}

func (r replaceAddr) RewriteRcpt(ctx context.Context, rcptTo string) (string, error) {
	if r.replaceRcpt {
		return r.rewrite(rcptTo)
	}
	return rcptTo, nil
}

func (r replaceAddr) RewriteBody(ctx context.Context, h *textproto.Header, body buffer.Buffer) error {
	return nil
}

func (r replaceAddr) Close() error {
	return nil
}

func (r replaceAddr) rewrite(val string) (string, error) {
	normAddr, err := address.ForLookup(val)
	if err != nil {
		return val, fmt.Errorf("malformed address: %v", err)
	}

	replacement, ok, err := r.table.Lookup(normAddr)
	if err != nil {
		return val, err
	}
	if ok {
		if !address.Valid(replacement) {
			return "", fmt.Errorf("refusing to replace recipient with the invalid address %s", replacement)
		}
		return replacement, nil
	}

	mbox, domain, err := address.Split(normAddr)
	if err != nil {
		// If we have malformed address here, something is really wrong, but let's
		// ignore it silently then anyway.
		return val, nil
	}

	// mbox is already normalized, since it is a part of address.ForLookup
	// result.
	replacement, ok, err = r.table.Lookup(mbox)
	if err != nil {
		return val, err
	}
	if ok {
		if strings.Contains(replacement, "@") && !strings.HasPrefix(replacement, `"`) && !strings.HasSuffix(replacement, `"`) {
			if !address.Valid(replacement) {
				return "", fmt.Errorf("refusing to replace recipient with invalid address %s", replacement)
			}
			return replacement, nil
		}
		return replacement + "@" + domain, nil
	}

	return val, nil
}

func init() {
	module.Register("replace_sender", NewReplaceAddr)
	module.Register("replace_rcpt", NewReplaceAddr)
}