// synops-mail — Send epost via msmtp.
//
// Sender epost via systemets msmtp-konfigurasjon.
// Avsender er alltid vaktmester@synops.no.
//
// Bruk:
//   synops-mail --send --to bruker@eksempel.no --subject "Emne"
//   echo "Brødtekst" | synops-mail --send --to bruker@eksempel.no --subject "Emne"
//   synops-mail --send --to bruker@eksempel.no --subject "Emne" --body "Tekst her"
//
// Output: Bekreftelse til stdout ved suksess.
// Feil: stderr + exit code != 0.
//
// Konfigurering:
//   msmtp-konfig: /srv/synops/config/msmtp/msmtprc
//   Miljøvariabel MSMTP_CONFIG kan overstyre config-sti.
//
// Ref: docs/retninger/unix_filosofi.md

use clap::Parser;
use std::io::{self, Read};
use std::process::{Command, Stdio};

const DEFAULT_FROM: &str = "vaktmester@synops.no";
const DEFAULT_FROM_NAME: &str = "Synops Vaktmester";
const DEFAULT_CONFIG: &str = "/srv/synops/config/msmtp/msmtprc";

/// Send epost via msmtp.
#[derive(Parser)]
#[command(name = "synops-mail", about = "Send epost via msmtp")]
struct Cli {
    /// Send-modus (påkrevd)
    #[arg(long)]
    send: bool,

    /// Mottaker-epostadresse
    #[arg(long)]
    to: String,

    /// Emne
    #[arg(long)]
    subject: String,

    /// Brødtekst (valgfritt — leses fra stdin om ikke oppgitt)
    #[arg(long)]
    body: Option<String>,

    /// Avsender (default: vaktmester@synops.no)
    #[arg(long, default_value = DEFAULT_FROM)]
    from: String,

    /// msmtp config-fil (default: /srv/synops/config/msmtp/msmtprc)
    #[arg(long, env = "MSMTP_CONFIG")]
    config: Option<String>,
}

fn main() {
    let cli = Cli::parse();

    if !cli.send {
        eprintln!("Feil: --send er påkrevd");
        std::process::exit(1);
    }

    // Les body fra --body eller stdin
    let body = match cli.body {
        Some(b) => b,
        None => {
            let mut buf = String::new();
            io::stdin().read_to_string(&mut buf).unwrap_or_else(|e| {
                eprintln!("Feil ved lesing fra stdin: {e}");
                std::process::exit(1);
            });
            if buf.is_empty() {
                eprintln!("Feil: Ingen --body og ingen data på stdin");
                std::process::exit(1);
            }
            buf
        }
    };

    let config_path = cli.config.unwrap_or_else(|| DEFAULT_CONFIG.to_string());

    // Bygg RFC 5322-melding
    let message = format!(
        "From: {from_name} <{from}>\r\n\
         To: {to}\r\n\
         Subject: {subject}\r\n\
         MIME-Version: 1.0\r\n\
         Content-Type: text/plain; charset=utf-8\r\n\
         Content-Transfer-Encoding: 8bit\r\n\
         \r\n\
         {body}",
        from_name = DEFAULT_FROM_NAME,
        from = cli.from,
        to = cli.to,
        subject = cli.subject,
        body = body,
    );

    // Send via msmtp
    let mut child = Command::new("msmtp")
        .args(["--file", &config_path, "--from", &cli.from, &cli.to])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap_or_else(|e| {
            eprintln!("Kunne ikke starte msmtp: {e}");
            std::process::exit(1);
        });

    // Skriv melding til msmtp stdin
    if let Some(mut stdin) = child.stdin.take() {
        use std::io::Write;
        stdin.write_all(message.as_bytes()).unwrap_or_else(|e| {
            eprintln!("Feil ved skriving til msmtp: {e}");
            std::process::exit(1);
        });
    }

    let output = child.wait_with_output().unwrap_or_else(|e| {
        eprintln!("Feil ved venting på msmtp: {e}");
        std::process::exit(1);
    });

    if output.status.success() {
        println!("Epost sendt til {}", cli.to);
    } else {
        let stderr = String::from_utf8_lossy(&output.stderr);
        eprintln!("msmtp feilet (exit {}): {}", output.status, stderr);
        std::process::exit(output.status.code().unwrap_or(1));
    }
}
