import { Credentials } from "@/lib/api";
import axios, {
  AxiosBasicCredentials,
  AxiosError,
  AxiosInstance,
  ResponseType,
} from "axios";
import { App, Plugin } from "vue";

export class Advent22 {
  private axios: AxiosInstance;
  private _api_auth: Credentials = ["", ""];

  public constructor() {
    this.axios = axios.create({
      timeout: 10000,
    });
  }

  private get api_baseurl(): string {
    // in production mode, return "//host/api"
    if (process.env.NODE_ENV === "production") {
      return `//${window.location.host}/api`;
    } else if (process.env.NODE_ENV !== "development") {
      // not in prouction or development mode
      console.warn("Unexpected NODE_ENV value");
    }

    // in development mode, return "//hostname:8000/api"
    return `//${window.location.hostname}:8000/api`;
  }

  public name_door(day: number): string {
    return `Türchen ${day}`;
  }

  public format_user_error([reason, endpoint]: [unknown, string]): string {
    let msg =
      "Unbekannter Fehler, bitte wiederholen! Besteht das Problem länger, bitte Admin benachrichtigen!";
    let code = "U";
    const result = () => `${msg} (Fehlercode: ${code}/${endpoint})`;

    if (!(reason instanceof AxiosError)) return result();

    switch (reason.code) {
      case "ECONNABORTED":
        // API unerreichbar
        msg =
          "API antwortet nicht, bitte später wiederholen! Besteht das Problem länger, bitte Admin benachrichtigen!";
        code = "D";
        break;

      case "ERR_NETWORK":
        // Netzwerk nicht verbunden
        msg = "Sieht aus, als sei deine Netzwerkverbindung gestört.";
        code = "N";
        break;

      default:
        if (reason.response === undefined) return result();

        switch (reason.response.status) {
          case 401:
            // UNAUTHORIZED
            msg = "Netter Versuch :)";
            code = "A";
            break;

          case 422:
            // UNPROCESSABLE ENTITY
            msg = "Funktion ist kaputt, bitte Admin benachrichtigen!";
            code = "I";
            break;

          default:
            // HTTP
            code = `H${reason.response.status}`;
            break;
        }
        break;
    }

    return result();
  }

  public get api_auth(): AxiosBasicCredentials {
    const [username, password] = this._api_auth;
    return { username: username, password: password };
  }

  public set_api_auth(): void;
  public set_api_auth(creds: Credentials): void;
  public set_api_auth(creds: Credentials = ["", ""]): void {
    this._api_auth = creds;
  }

  public clear_api_auth(): void {
    this.set_api_auth();
  }

  public set api_auth(creds: Credentials) {
    this.set_api_auth(creds);
  }

  public api_url(): string;
  public api_url(endpoint: string): string;
  public api_url(endpoint?: string): string {
    if (endpoint === undefined) {
      return this.api_baseurl;
    }

    while (endpoint.startsWith("/")) {
      endpoint = endpoint.substring(1);
    }

    return `${this.api_baseurl}/${endpoint}`;
  }

  private _api_get<T>(endpoint: string): Promise<T>;
  private _api_get<T>(endpoint: string, responseType: ResponseType): Promise<T>;
  private _api_get<T>(
    endpoint: string,
    responseType: ResponseType = "json",
  ): Promise<T> {
    const req_config = {
      auth: this.api_auth,
      responseType: responseType,
    };

    return new Promise<T>((resolve, reject) => {
      this.axios
        .get<T>(this.api_url(endpoint), req_config)
        .then((response) => resolve(response.data))
        .catch((reason) => {
          console.error(`Failed to query ${endpoint}: ${reason}`);
          reject([reason, endpoint]);
        });
    });
  }

  public api_get<T>(endpoint: string): Promise<T> {
    return this._api_get<T>(endpoint);
  }

  public api_get_blob(endpoint: string): Promise<string> {
    return new Promise<string>((resolve, reject) => {
      this._api_get<Blob>(endpoint, "blob")
        .then((data: Blob) => {
          const reader = new FileReader();
          reader.readAsDataURL(data);
          reader.onloadend = () => {
            if (typeof reader.result === "string") {
              resolve(reader.result);
            } else {
              reject(["failed data url", endpoint]);
            }
          };
        })
        .catch(reject);
    });
  }

  public api_put(endpoint: string, data: unknown): Promise<void> {
    const req_config = {
      auth: this.api_auth,
    };

    return new Promise<void>((resolve, reject) => {
      this.axios
        .put(this.api_url(endpoint), data, req_config)
        .then(() => resolve())
        .catch((reason) => {
          console.error(`Failed to query ${endpoint}: ${reason}`);
          reject([reason, endpoint]);
        });
    });
  }
}

export const Advent22Plugin: Plugin = {
  install(app: App) {
    app.config.globalProperties.$advent22 = new Advent22();
  },
};