package backend

import (
	"bytes"
	"encoding/base64"
	"fmt"
	"html"
	"io"
	"mime"
	"mime/multipart"
	"mime/quotedprintable"
	"net/mail"
	"os"
	"path/filepath"
	"strings"
	"time"
)

// mbox ist das lokale Cold-Backup-Format: eine Datei pro IMAP-Ordner, der
// Ordnerbaum 1:1 auf der Platte. eM Client / Thunderbird importieren mbox
// direkt. (Kein PST -- das laesst sich in Go nicht lean schreiben.)

// MboxWriter haengt Nachrichten an die mbox-Datei eines Ordners an.
type MboxWriter struct {
	root string
}

// NewMboxWriter legt <mboxRoot>/<account>/ an und spiegelt den Ordnerbaum.
func NewMboxWriter(dir string) (*MboxWriter, error) {
	if err := os.MkdirAll(dir, 0o700); err != nil {
		return nil, err
	}
	return &MboxWriter{root: dir}, nil
}

// Append schreibt eine Mail im mbox-Format ("From "-Trennzeile, >From-Quoting)
// in <ordner>.mbox.
func (w *MboxWriter) Append(folder string, m RawMessage) error {
	path := filepath.Join(w.root, safeMboxName(folder)+".mbox")
	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
		return err
	}
	f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
	if err != nil {
		return err
	}
	defer f.Close()
	fromDate := m.InternalDate
	if fromDate.IsZero() {
		fromDate = time.Now()
	}
	if _, err := fmt.Fprintf(f, "From MAILER-DAEMON %s\r\n", fromDate.Format("Mon Jan _2 15:04:05 2006")); err != nil {
		return err
	}
	body := bytes.ReplaceAll(m.Body, []byte("\r\nFrom "), []byte("\r\n>From "))
	body = bytes.ReplaceAll(body, []byte("\nFrom "), []byte("\n>From "))
	if _, err := f.Write(body); err != nil {
		return err
	}
	if !bytes.HasSuffix(body, []byte("\n")) {
		if _, err := f.WriteString("\r\n"); err != nil {
			return err
		}
	}
	_, err = f.WriteString("\r\n")
	return err
}

// --- Viewer-Seite: mbox wieder lesen fuers Browser-Betrachten (08-viewer.go) ---

// MboxEntry ist eine Nachricht wie im Listen-Pane angezeigt.
type MboxEntry struct {
	Index   int
	From    string
	Subject string
	Date    string
}

// ReadMboxList parst die Kopfzeilen aller Mails einer mbox-Datei (fuer die
// Nachrichtenliste). ReadMboxMessage liefert eine einzelne Mail als Rohtext.
func ReadMboxList(path string) ([]MboxEntry, error) {
	msgs, err := readMboxMessages(path)
	if err != nil {
		return nil, err
	}
	out := make([]MboxEntry, 0, len(msgs))
	for i, raw := range msgs {
		msg, err := mail.ReadMessage(bytes.NewReader(raw))
		if err != nil {
			out = append(out, MboxEntry{Index: i, From: "(unlesbar)", Subject: "Unlesbare Nachricht"})
			continue
		}
		out = append(out, MboxEntry{
			Index:   i,
			From:    decodeHeader(msg.Header.Get("From")),
			Subject: decodeHeader(msg.Header.Get("Subject")),
			Date:    decodeHeader(msg.Header.Get("Date")),
		})
	}
	return out, nil
}

func ReadMboxMessage(path string, index int) ([]byte, error) {
	msgs, err := readMboxMessages(path)
	if err != nil {
		return nil, err
	}
	if index < 0 || index >= len(msgs) {
		return nil, fmt.Errorf("message index out of range")
	}
	return msgs[index], nil
}

func readMboxMessages(path string) ([][]byte, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	b = bytes.ReplaceAll(b, []byte("\r\n"), []byte("\n"))
	lines := bytes.Split(b, []byte("\n"))
	var msgs [][]byte
	var cur bytes.Buffer
	inMsg := false
	for _, line := range lines {
		if bytes.HasPrefix(line, []byte("From ")) {
			if inMsg && cur.Len() > 0 {
				msgs = append(msgs, bytes.TrimRight(cur.Bytes(), "\n"))
				cur.Reset()
			}
			inMsg = true
			continue
		}
		if !inMsg {
			continue
		}
		if bytes.HasPrefix(line, []byte(">From ")) {
			line = line[1:]
		}
		_, _ = cur.Write(line)
		_ = cur.WriteByte('\n')
	}
	if inMsg && cur.Len() > 0 {
		msgs = append(msgs, bytes.TrimRight(cur.Bytes(), "\n"))
	}
	return msgs, nil
}

func decodeHeader(v string) string {
	v = strings.TrimSpace(v)
	if v == "" {
		return ""
	}
	decoded, err := new(mime.WordDecoder).DecodeHeader(v)
	if err != nil {
		return v
	}
	return decoded
}

func messageBody(raw []byte) string {
	msg, err := mail.ReadMessage(bytes.NewReader(raw))
	if err != nil {
		return string(raw)
	}
	body, err := io.ReadAll(msg.Body)
	if err != nil {
		return string(raw)
	}
	return extractTextBody(msg.Header, body)
}

type headerGetter interface {
	Get(string) string
}

func extractTextBody(h headerGetter, body []byte) string {
	mediaType, params, _ := mime.ParseMediaType(h.Get("Content-Type"))
	decoded := decodeTransfer(body, h.Get("Content-Transfer-Encoding"))
	if strings.HasPrefix(mediaType, "multipart/") {
		boundary := params["boundary"]
		if boundary == "" {
			return string(decoded)
		}
		mr := multipart.NewReader(bytes.NewReader(decoded), boundary)
		var htmlBody string
		for {
			part, err := mr.NextPart()
			if err == io.EOF {
				break
			}
			if err != nil {
				break
			}
			partBody, _ := io.ReadAll(part)
			text := extractTextBody(part.Header, partBody)
			partType, _, _ := mime.ParseMediaType(part.Header.Get("Content-Type"))
			if strings.HasPrefix(partType, "text/plain") && strings.TrimSpace(text) != "" {
				return text
			}
			if strings.HasPrefix(partType, "text/html") && htmlBody == "" {
				htmlBody = text
			}
		}
		if htmlBody != "" {
			return htmlBody
		}
		return ""
	}
	if strings.HasPrefix(mediaType, "text/html") || looksLikeHTML(decoded) {
		return htmlToText(string(decoded))
	}
	return string(decoded)
}

func looksLikeHTML(body []byte) bool {
	s := strings.ToLower(strings.TrimSpace(string(body)))
	return strings.HasPrefix(s, "<!doctype html") || strings.HasPrefix(s, "<html") || strings.Contains(s, "<body")
}

func htmlToText(s string) string {
	s = stripHTMLBlock(s, "script")
	s = stripHTMLBlock(s, "style")
	s = markHTMLBreaks(s)
	var b strings.Builder
	inTag := false
	lastSpace := false
	for _, r := range s {
		switch r {
		case '<':
			inTag = true
			if !lastSpace {
				b.WriteByte(' ')
				lastSpace = true
			}
		case '>':
			inTag = false
		default:
			if inTag {
				continue
			}
			if r == '\n' {
				b.WriteByte('\n')
				lastSpace = true
				continue
			}
			if r == '\r' || r == '\t' || r == ' ' {
				if !lastSpace {
					b.WriteByte(' ')
					lastSpace = true
				}
				continue
			}
			b.WriteRune(r)
			lastSpace = false
		}
	}
	text := html.UnescapeString(b.String())
	lines := strings.Split(text, "\n")
	out := make([]string, 0, len(lines))
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line != "" {
			out = append(out, line)
		}
	}
	if len(out) == 0 {
		return strings.TrimSpace(text)
	}
	return strings.Join(out, "\n")
}

func markHTMLBreaks(s string) string {
	repls := []struct {
		Needle string
		With   string
	}{
		{"<br>", "\n"},
		{"<br/>", "\n"},
		{"<br />", "\n"},
		{"</p>", "\n"},
		{"</div>", "\n"},
		{"</tr>", "\n"},
		{"</td>", " "},
		{"</th>", " "},
		{"</li>", "\n"},
	}
	for _, repl := range repls {
		s = replaceCaseInsensitive(s, repl.Needle, repl.With)
	}
	return s
}

func replaceCaseInsensitive(s, old, new string) string {
	var b strings.Builder
	lower := strings.ToLower(s)
	needle := strings.ToLower(old)
	for {
		i := strings.Index(lower, needle)
		if i < 0 {
			b.WriteString(s)
			return b.String()
		}
		b.WriteString(s[:i])
		b.WriteString(new)
		cut := i + len(old)
		s = s[cut:]
		lower = lower[cut:]
	}
}

func stripHTMLBlock(s, tag string) string {
	lower := strings.ToLower(s)
	open := "<" + tag
	close := "</" + tag + ">"
	for {
		start := strings.Index(lower, open)
		if start < 0 {
			return s
		}
		end := strings.Index(lower[start:], close)
		if end < 0 {
			return s[:start]
		}
		end += start + len(close)
		s = s[:start] + " " + s[end:]
		lower = strings.ToLower(s)
	}
}

func decodeTransfer(body []byte, enc string) []byte {
	switch strings.ToLower(strings.TrimSpace(enc)) {
	case "quoted-printable":
		b, err := io.ReadAll(quotedprintable.NewReader(bytes.NewReader(body)))
		if err == nil {
			return b
		}
	case "base64":
		cleaned := strings.NewReplacer("\r", "", "\n", "", " ", "", "\t", "").Replace(string(body))
		b, err := base64.StdEncoding.DecodeString(cleaned)
		if err == nil {
			return b
		}
	}
	return body
}

func safeMboxName(folder string) string {
	folder = strings.TrimSpace(folder)
	folder = strings.ReplaceAll(folder, "\\", "_")
	folder = strings.ReplaceAll(folder, "/", "_")
	folder = strings.ReplaceAll(folder, ":", "_")
	if folder == "" {
		return "INBOX"
	}
	return folder
}