import { encodeBase64 } from "@std/encoding/base64";
import { parse } from "@std/csv/parse";
import { simpleParseMail } from "./mail-parsing.ts";

export class Mail {
  #raw;
  #parsed;

  constructor(raw: string) {
    this.#raw = raw;
    this.#parsed = simpleParseMail(raw);
  }

  get raw() {
    return this.#raw;
  }

  set raw(value) {
    this.#raw = value;
    this.#parsed = simpleParseMail(value);
  }

  get parsed() {
    return this.#parsed;
  }

  toUtf8Bytes(): Uint8Array {
    const utf8Encoder = new TextEncoder();
    return utf8Encoder.encode(this.raw);
  }

  toBase64(): string {
    return encodeBase64(this.raw);
  }

  simpleFindAllAddresses(): string[] {
    const re = /,?\<?([a-z0-9_'+\-\.]+\@[a-z0-9_'+\-\.]+)\>?,?/gi;
    return [...this.raw.matchAll(re)].map((m) => m[1]);
  }
}

export interface MailDeliverRecipientResult {
  kind: "success" | "failure";
  message?: string;
  cause?: unknown;
}

export class MailDeliverResult {
  message?: string;
  smtpMessage?: string;
  recipients = new Map<string, MailDeliverRecipientResult>();
  constructor(public mail: Mail) {}
}

export class MailDeliverContext {
  readonly recipients: Set<string> = new Set();
  readonly result;

  constructor(public mail: Mail) {
    this.result = new MailDeliverResult(this.mail);
  }
}

export interface MailDeliverHook {
  callback(context: MailDeliverContext): Promise<void>;
}

export abstract class MailDeliverer {
  preHooks: MailDeliverHook[] = [];
  postHooks: MailDeliverHook[] = [];

  protected abstract doDeliver(
    mail: Mail,
    context: MailDeliverContext,
  ): Promise<void>;

  async deliverRaw(rawMail: string) {
    return await this.deliver({ mail: new Mail(rawMail) });
  }

  async deliver(options: {
    mail: Mail;
    recipients?: string[];
  }): Promise<MailDeliverResult> {
    const context = new MailDeliverContext(options.mail);
    options.recipients?.forEach((r) => context.recipients.add(r));

    console.info("Begin to deliver mail to...");

    for (const hook of this.preHooks) {
      await hook.callback(context);
    }

    await this.doDeliver(context.mail, context);

    for (const hook of this.postHooks) {
      await hook.callback(context);
    }

    console.info("Deliver result:", context.result);

    return context.result;
  }
}

export abstract class SyncMailDeliverer extends MailDeliverer {
  #last: Promise<void> = Promise.resolve();

  override async deliver(options: {
    mail: Mail;
    recipients?: string[];
  }): Promise<MailDeliverResult> {
    console.info(
      "The mail deliverer is sync. Wait for last delivering done...",
    );
    await this.#last;
    const result = super.deliver(options);
    this.#last = result.then(
      () => {},
      () => {},
    );
    return result;
  }
}

export class RecipientFromHeadersHook implements MailDeliverHook {
  constructor(public mailDomain: string) {}

  callback(context: MailDeliverContext) {
    if (context.recipients.size !== 0) {
      console.warn(
        "Recipients are already filled, skip inferring from headers.",
      );
    } else {
      [...context.mail.parsed.recipients].filter((r) =>
        r.endsWith("@" + this.mailDomain)
      ).forEach((r) => context.recipients.add(r));

      console.info(
        "Use recipients inferred from mail headers:",
        [...context.recipients].join(", "),
      );
    }
    return Promise.resolve();
  }
}

export class FallbackRecipientHook implements MailDeliverHook {
  constructor(public fallback: Set<string> = new Set()) {}

  callback(context: MailDeliverContext) {
    if (context.recipients.size === 0) {
      console.info("Use fallback recipients:" + [...this.fallback].join(", "));
      this.fallback.forEach((a) => context.recipients.add(a));
    }
    return Promise.resolve();
  }
}

export class AliasRecipientMailHook implements MailDeliverHook {
  #aliasFile;

  constructor(aliasFile: string) {
    this.#aliasFile = aliasFile;
  }

  async #parseAliasFile(): Promise<Map<string, string>> {
    const result = new Map();
    if ((await Deno.stat(this.#aliasFile)).isFile) {
      const text = await Deno.readTextFile(this.#aliasFile);
      const csv = parse(text);
      for (const [real, ...aliases] of csv) {
        aliases.forEach((a) => result.set(a, real));
      }
    } else {
      console.warn(`Recipient alias file ${this.#aliasFile} is not found.`);
    }
    return result;
  }

  async callback(context: MailDeliverContext) {
    const aliases = await this.#parseAliasFile();
    for (const recipient of [...context.recipients]) {
      const realRecipients = aliases.get(recipient);
      if (realRecipients != null) {
        console.info(
          `Recipient alias resolved: ${recipient} => ${realRecipients}.`,
        );
        context.recipients.delete(recipient);
        context.recipients.add(realRecipients);
      }
    }
  }
}