/*
Copyright 2022 CAcert Inc.
SPDX-License-Identifier: Apache-2.0

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package main

import (
	"bytes"
	"fmt"
	"path"
	"text/template"

	"github.com/Masterminds/sprig/v3"
	"gopkg.in/mail.v2"

	"git.cacert.org/cacert-boardvoting/internal"
	"git.cacert.org/cacert-boardvoting/internal/models"
)

type recipientData struct {
	field, address, name string
}

type NotificationContent struct {
	template   string
	data       interface{}
	subject    string
	headers    map[string][]string
	recipients []recipientData
}

type NotificationMail interface {
	GetNotificationContent(*mailConfig) *NotificationContent
}

type MailNotifier struct {
	notifyChannel chan NotificationMail
	senderAddress string
	dialer        *mail.Dialer
	quitChannel   chan struct{}
}

func (app *application) NewMailNotifier() {
	app.mailNotifier = &MailNotifier{
		notifyChannel: make(chan NotificationMail, 1),
		senderAddress: app.mailConfig.NotificationSenderAddress,
		dialer:        mail.NewDialer(app.mailConfig.SMTPHost, app.mailConfig.SMTPPort, "", ""),
		quitChannel:   make(chan struct{}),
	}
}

func (app *application) StartMailNotifier() {
	app.infoLog.Print("Launching mail notifier")

	for {
		select {
		case notification := <-app.mailNotifier.notifyChannel:
			content := notification.GetNotificationContent(app.mailConfig)

			mailText, err := content.buildMail(app.mailConfig.BaseURL)
			if err != nil {
				app.errorLog.Printf("building mail failed: %v", err)

				continue
			}

			m := mail.NewMessage()

			m.SetHeaders(content.headers)
			m.SetAddressHeader("From", app.mailNotifier.senderAddress, "CAcert board voting system")

			for _, recipient := range content.recipients {
				m.SetAddressHeader(recipient.field, recipient.address, recipient.name)
			}

			m.SetHeader("Subject", content.subject)

			m.SetBody("text/plain", mailText.String())

			if err = app.mailNotifier.dialer.DialAndSend(m); err != nil {
				app.errorLog.Printf("sending mail failed: %v", err)
			}
		case <-app.mailNotifier.quitChannel:
			app.infoLog.Print("ending mail notifier")

			return
		}
	}
}

func (m *MailNotifier) Quit() {
	m.quitChannel <- struct{}{}
}

func (n *NotificationContent) buildMail(baseURL string) (fmt.Stringer, error) {
	b, err := internal.MailTemplates.ReadFile(path.Join("mailtemplates", n.template))
	if err != nil {
		return nil, fmt.Errorf("could not read mail template %s: %w", n.template, err)
	}

	t, err := template.New(n.template).Funcs(sprig.GenericFuncMap()).Parse(string(b))
	if err != nil {
		return nil, fmt.Errorf("could not parse mail template %s: %w", n.template, err)
	}

	data := struct {
		Data    any
		BaseURL string
	}{Data: n.data, BaseURL: baseURL}

	mailText := bytes.NewBuffer(make([]byte, 0))
	if err = t.Execute(mailText, data); err != nil {
		return nil, fmt.Errorf(
			"failed to execute template %s with context %v: %w", n.template, n.data, err)
	}

	return mailText, nil
}

type RemindVoterNotification struct {
	voter     *models.User
	decisions []*models.Motion
}

func (r RemindVoterNotification) GetNotificationContent(*mailConfig) *NotificationContent {
	return &NotificationContent{
		template: "remind_voter_mail.txt",
		data: struct {
			Decisions []*models.Motion
			Name      string
		}{Decisions: r.decisions, Name: r.voter.Name},
		subject:    "Outstanding CAcert board votes",
		recipients: []recipientData{{"To", r.voter.Reminder, r.voter.Name}},
	}
}

func defaultRecipient(mc *mailConfig) recipientData {
	return recipientData{field: "To", address: mc.NoticeMailAddress, name: "CAcert board mailing list"}
}

type ClosedDecisionNotification struct {
	decision *models.ClosedMotion
}

func (c *ClosedDecisionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
	return &NotificationContent{
		template:   "closed_motion_mail.txt",
		data:       c.decision,
		subject:    fmt.Sprintf("Re: %s - %s - finalised", c.decision.Decision.Tag, c.decision.Decision.Title),
		headers:    c.getHeaders(),
		recipients: []recipientData{defaultRecipient(mc)},
	}
}

func (c *ClosedDecisionNotification) getHeaders() map[string][]string {
	return map[string][]string{
		"References":  {fmt.Sprintf("<%s>", c.decision.Decision.Tag)},
		"In-Reply-To": {fmt.Sprintf("<%s>", c.decision.Decision.Tag)},
	}
}

type NewDecisionNotification struct {
	decision *models.NewMotion
}

func (n NewDecisionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
	voteURL := fmt.Sprintf("/vote/%s", n.decision.Decision.Tag)
	unvotedURL := "/motions/?unvoted=1"

	return &NotificationContent{
		template: "create_motion_mail.txt",
		data: struct {
			*models.Motion
			Name       string
			VoteURL    string
			UnvotedURL string
		}{n.decision.Decision, n.decision.Proposer.Name, voteURL, unvotedURL},
		subject:    fmt.Sprintf("%s - %s", n.decision.Decision.Tag, n.decision.Decision.Title),
		headers:    n.getHeaders(),
		recipients: []recipientData{defaultRecipient(mc)},
	}
}

func (n NewDecisionNotification) getHeaders() map[string][]string {
	return map[string][]string{
		"Message-ID": {fmt.Sprintf("<%s>", n.decision.Decision.Tag)},
	}
}