import type { ResponseType } from 'axios';
import { z } from 'zod';

import { getUri } from '../../operators/getUri.js';
import { healthcheck } from '../../operators/healthCheck.js';
import { request } from '../../operators/request.js';
import {
  getDefaultResponseType,
  type RequestResponseReturnType,
  type RequestResponseType
} from '../../shared.js';
import type { ThreekitAuthProps } from '../../ThreekitAuthProps.js';
import { Route } from '../Route.js';

export enum ImageTransformExtension {
  Png = 'png',
  Jpg = 'jpg',
  Webp = 'webp'
}

export const ImageTransformProps = z.object({
  sourceUrl: z.string(),
  width: z.number().optional(),
  height: z.number().optional(),
  quality: z.number().optional(),
  format: z.nativeEnum(ImageTransformExtension).optional()
});
export type ImageTransformProps = z.infer<typeof ImageTransformProps>;

const API_ROUTE = `/api/images`;

export class Images extends Route {
  constructor(auth: ThreekitAuthProps) {
    super(auth, API_ROUTE);
  }

  healthcheck() {
    return healthcheck(this.context);
  }

  static getTransformUrlPath(props: ImageTransformProps) {
    const { sourceUrl, width, height, quality, format } = props;
    let path = 'webp'; // this just specifies that it uses ImageMagick rather than GraphicsMagic and thus it supports webp.
    if (width !== undefined || height !== undefined) {
      path += `/${width ?? 0}`;
      path += 'x';
      path += `${height ?? 0}`;
    }
    if (format !== undefined || quality !== undefined) {
      const filters = ['filters'];
      if (format !== undefined) {
        filters.push(`format(${format})`);
      }
      if (quality !== undefined) {
        filters.push(`quality(${quality})`);
      }
      path += `/${filters.join(':')}`;
    }
    path += `/${sourceUrl}`;
    return path;
  }

  getTransformUrl(props: ImageTransformProps) {
    return getUri(this.context, {
      url: Images.getTransformUrlPath(props)
    });
  }

  transform<T extends RequestResponseType>(
    props: ImageTransformProps,
    responseType = getDefaultResponseType<T>()
  ) {
    return request<RequestResponseReturnType<T>>(this.context, {
      url: Images.getTransformUrlPath(props),
      responseType: responseType as ResponseType
    });
  }
}