import {
  ElementSchema,
  ElementTypeDefinition,
  GetAttributesResponse,
  OrganizationSettings,
  SchemaHistoryEntry,
  SchemaHistorySummary,
  SchemaId,
  Scope,
  ScopeResponse,
  Stage,
  Template,
  TemplateHistoryEntry,
  TemplateHistorySummary,
  TemplateId,
} from '../../interfaces'
import { Api } from '../api'

export const EDITORS_API = '/service/editors/new'

export const DEFAULT_TEMPLATE_ID = 'Default'

type ShortStage = 'prod' | 'stage'

export const SHORT_STAGE_MAP: Record<Stage, ShortStage> = {
  production: 'prod',
  stage: 'stage',
}

export class Editors {
  api: Api

  constructor(api: Api) {
    this.api = api
  }

  // V1
  getLegacyTypeDefinition(type: string) {
    return this.api.apisauce.get<ElementTypeDefinition>(
      `${EDITORS_API}/v1/elementtypes/${type}`,
    )
  }

  // V2
  addSchema(
    data: Required<Pick<ElementSchema, 'id' | 'scope' | 'properties'>>,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.post<ElementSchema, void>(
      `${EDITORS_API}/v2/schema`,
      data,
      {
        params: options?.stage
          ? { stage: SHORT_STAGE_MAP[options.stage] }
          : undefined,
      },
    )
  }

  getScope(scope?: Scope, options?: { stage?: Stage }) {
    return this.api.apisauce.get<ScopeResponse, void>(
      `${EDITORS_API}/v2/schema${scope ? `/${scope}` : ''}`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  getAttributeSummary(scope?: Scope, options?: { stage?: Stage }) {
    return this.api.apisauce.get<GetAttributesResponse, void>(
      `${EDITORS_API}/v2/attributes${scope ? `/${scope}` : ''}`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  getScopeList(options?: { stage?: Stage }) {
    return this.api.apisauce.get<{ id: string; name: string }[], void>(
      `${EDITORS_API}/v2/scopes`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  getTypeSchema(
    schemaId: SchemaId,
    options?: { stage?: Stage; cache?: false },
  ) {
    return this.api.apisauce.get<ElementSchema, void>(
      `${EDITORS_API}/v2/schema/${schemaId}`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
      options?.cache !== undefined
        ? {
            cache: options?.cache,
          }
        : undefined,
    )
  }

  saveTypeSchema(
    schemaId: SchemaId,
    data: Partial<ElementSchema>,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.post<
      ElementSchema & { children?: ElementSchema[] },
      void
    >(`${EDITORS_API}/v2/schema/${schemaId}`, data, {
      params: options?.stage
        ? { stage: SHORT_STAGE_MAP[options.stage] }
        : undefined,
    })
  }

  getTemplate(
    schemaId: SchemaId,
    templateId = DEFAULT_TEMPLATE_ID,
    options?: { stage?: Stage; cache?: false; strict?: boolean },
  ) {
    const params: Record<string, string> = {}

    if (options?.strict) {
      params.strict = 'true'
    }

    if (options?.stage) {
      params.stage = SHORT_STAGE_MAP[options.stage]
    }

    return this.api.apisauce.get<Template, void>(
      `${EDITORS_API}/v2/template/${schemaId}/${templateId}`,
      params,
      options?.cache !== undefined
        ? {
            cache: options?.cache,
          }
        : undefined,
    )
  }

  saveTemplate(
    schemaId: SchemaId,
    templateId?: TemplateId,
    data?: Partial<Template>,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.post<Template, void>(
      `${EDITORS_API}/v2/template/${schemaId}${
        templateId ? `/${templateId}` : ''
      }`,
      data,
      {
        params: options?.stage
          ? { stage: SHORT_STAGE_MAP[options.stage] }
          : undefined,
      },
    )
  }

  getSchemasSummary(options?: { stage?: Stage }) {
    return this.api.apisauce.get<
      Record<
        string,
        { schema: string; templates?: string[]; organizationId?: string[] }[]
      >,
      void
    >(
      `${EDITORS_API}/v2/schemas/summary`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  getSchemasSummaryFull(options?: { stage?: Stage }) {
    return this.api.apisauce.get<
      Record<string, Record<string, ElementSchema>>,
      void
    >(
      `${EDITORS_API}/v2/schemas`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  getOrganizationSettings(organization: string, options?: { stage?: Stage }) {
    return this.api.apisauce.get<OrganizationSettings, void>(
      `${EDITORS_API}/v2/organizations/${organization}/settings`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  upsertOrganizationSettings(
    data: OrganizationSettings,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.put<OrganizationSettings, void>(
      `${EDITORS_API}/v2/organizations/settings`,
      data,
      {
        params: options?.stage
          ? { stage: SHORT_STAGE_MAP[options.stage] }
          : undefined,
      },
    )
  }

  cloneEditorsData(
    sourceOrganization: string,
    destinationOrganization: string,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.post<
      { schemas: string[]; templates: string[] },
      void
    >(
      `${EDITORS_API}/v2/organizations/clone`,
      {
        source: sourceOrganization,
        destination: destinationOrganization,
      },
      {
        params: options?.stage
          ? { stage: SHORT_STAGE_MAP[options.stage] }
          : undefined,
      },
    )
  }

  /**
   * Get list of template history entries (summary only)
   * @param scope - Template scope (e.g., "shared", organization ID)
   * @param elementId - Element/schema ID
   * @param templateId - Template ID
   * @param options - Optional parameters including stage
   * @returns Array of history summaries
   */
  getTemplateHistory(
    scope: Scope,
    elementId: string,
    templateId: TemplateId,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.get<TemplateHistorySummary[], void>(
      `${EDITORS_API}/v2/template/${scope}/${elementId}/${templateId}/history`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  /**
   * Get specific template history entry with full content
   * @param scope - Template scope
   * @param elementId - Element/schema ID
   * @param templateId - Template ID
   * @param historyId - MongoDB ObjectId of the history entry
   * @param options - Optional parameters including stage
   * @returns Full history entry
   */
  getTemplateHistoryEntry(
    scope: Scope,
    elementId: string,
    templateId: TemplateId,
    historyId: string,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.get<TemplateHistoryEntry, void>(
      `${EDITORS_API}/v2/template/${scope}/${elementId}/${templateId}/history/${historyId}`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  /**
   * Get list of schema history entries (summary only)
   * @param scope - Schema scope (e.g., "shared", organization ID)
   * @param id - Schema ID
   * @param options - Optional parameters including stage
   * @returns Array of history summaries
   */
  getSchemaHistory(scope: Scope, id: string, options?: { stage?: Stage }) {
    return this.api.apisauce.get<SchemaHistorySummary[], void>(
      `${EDITORS_API}/v2/schema/${scope}/${id}/history`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }

  /**
   * Get specific schema history entry with full content
   * @param scope - Schema scope
   * @param id - Schema ID
   * @param historyId - MongoDB ObjectId of the history entry
   * @param options - Optional parameters including stage
   * @returns Full history entry
   */
  getSchemaHistoryEntry(
    scope: Scope,
    id: string,
    historyId: string,
    options?: { stage?: Stage },
  ) {
    return this.api.apisauce.get<SchemaHistoryEntry, void>(
      `${EDITORS_API}/v2/schema/${scope}/${id}/history/${historyId}`,
      options?.stage ? { stage: SHORT_STAGE_MAP[options.stage] } : undefined,
    )
  }
}