import z from 'zod';
import {
  authedServiceRequest,
  serviceRequest,
  serviceResponse,
} from '../interfaces/common';
import { metadata } from '../interfaces/Metadata';
import { bot } from './BotService';
import { file } from './FileService';
import { invoice } from './InvoiceService';
import { subscription } from './SubscriptionService';
import { sync } from './SyncService';

export const zSourceTypes = z.enum([
  'YouTube',
  'RSS',
  'SiteMap',
  'Files',
  'WARC',
]);

export const source = z.object({
  _id: z.string(),
  organizationId: z.string(),
  syncId: z.string().optional(),
  title: z.string(),
  description: z.string().optional(),
  imageFileId: z.string().nullable().optional(),
  type: zSourceTypes,
  importUrl: z.string().optional(),
  transcribe: z.boolean().optional(),
  regex: z.string().nullable().optional(),
  durationSeconds: z.number().optional(),
  documentCount: z.number(),
  archived: z.boolean().optional(),
  meta: metadata,
});

export const sourceFiles = z.object({
  imageFile: file.nullable(),
  coverImageFile: file.nullable(),
  sponsorImageFile: file.nullable(),
});

export const sourceImportInfo = z.object({
  title: z.string(),
  imageUrl: z.string().optional(),
  documentCount: z.number(),
  durationHours: z.number().optional(),
  durationSeconds: z.number().optional(),
  transcriptionCost: z.number().optional(),
  error: z.string().optional(),
});

export type SourceTypes = z.infer<typeof zSourceTypes>;
export type Source = z.infer<typeof source>;
export type SourceFiles = z.infer<typeof sourceFiles>;
export type SourceImportInfo = z.infer<typeof sourceImportInfo>;

export type SourceResolved = Source & {
  files: SourceFiles;
};

export interface SourceService {
  add(request: AddSourceRequest): Promise<AddSourceResponse>;
  edit(request: EditSourceRequest): Promise<EditSourceResponse>;
  sync(request: SyncSourceRequest): Promise<SyncSourceResponse>;
  archive(request: ArchiveSourceRequest): Promise<ArchiveSourceResponse>;
  get(request: GetSourceRequest): Promise<GetSourceResponse>;
  list(request: ListSourcesRequest): Promise<ListSourcesResponse>;
  importInfo(request: GetSourceImportInfoRequest): Promise<GetSourceImportInfoResponse>;
}

/** ******************************************************************************
*  Add Source
******************************************************************************* */

export const addSourceParams = z.object({
  botId: z.string().optional(),
  title: z.string(),
  description: z.string(),
  imageFileId: z.string(),
  importUrl: z.string().url().optional(),
  transcribe: z.boolean().optional(),
  regex: z.string().nullable().optional(),
  stripePriceId: z.string().optional(),
  type: zSourceTypes,
});

export const addSourceRequest = authedServiceRequest.merge(
  z.object({
    params: addSourceParams,
  }),
);

export const addSourceResponse = serviceResponse.merge(
  z.object({
    source: source.optional(),
    sync: sync.nullable().optional(),
    subscription: subscription.nullable().optional(),
  }),
);

export type AddSourceParams = z.infer<typeof addSourceParams>;
export type AddSourceRequest = z.infer<typeof addSourceRequest>;
export type AddSourceResponse = z.infer<typeof addSourceResponse>;

/** ******************************************************************************
*  Edit Source
******************************************************************************* */

export const editSourceParams = z.object({
  _id: z.string(),
  title: z.string().min(4).max(64),
  description: z.string(),
  imageFileId: z.string(),
  transcribe: z.boolean(),
  regex: z.string().nullable(),
});

export const editSourceRequest = authedServiceRequest.merge(
  z.object({
    params: editSourceParams,
  }),
);

export const editSourceResponse = serviceResponse.merge(
  z.object({
    source: source.optional(),
    sessionUrl: z.string().optional(),
  }),
);

export type EditSourceParams = z.infer<typeof editSourceParams>;
export type EditSourceRequest = z.infer<typeof editSourceRequest>;
export type EditSourceResponse = z.infer<typeof editSourceResponse>;

/** ******************************************************************************
*  Sync Source
******************************************************************************* */

export const syncSourceParams = z.object({
  _id: z.string(),
  syncId: z.string(),
});

export const syncSourceRequest = serviceRequest.merge(
  z.object({
    params: syncSourceParams,
  }),
);

export const syncSourceResponse = serviceResponse.merge(
  z.object({
    source: source.optional(),
    lastSyncId: z.string().optional(),
  }),
);

export type SyncSourceParams = z.infer<typeof syncSourceParams>;
export type SyncSourceRequest = z.infer<typeof syncSourceRequest>;
export type SyncSourceResponse = z.infer<typeof syncSourceResponse>;

/** ******************************************************************************
*  Archive Source
******************************************************************************* */

export const archiveSourceParams = z.object({
  _id: z.string(),
  archived: z.boolean(),
});

export const archiveSourceRequest = authedServiceRequest.merge(
  z.object({
    params: archiveSourceParams,
  }),
);

export const archiveSourceResponse = serviceResponse.merge(
  z.object({
    source: source.nullable().optional(),
    bots: z.array(bot).optional(),
    invoice: invoice.nullable().optional(),
  }),
);

export type ArchiveSourceParams = z.infer<typeof archiveSourceParams>;
export type ArchiveSourceRequest = z.infer<typeof archiveSourceRequest>;
export type ArchiveSourceResponse = z.infer<typeof archiveSourceResponse>;

/** ******************************************************************************
*  Get Source
******************************************************************************* */

export const getSourceParams = z.object({
  sourceId: z.string(),
});

export const getSourceRequest = serviceRequest.merge(
  z.object({
    params: getSourceParams,
  }),
);

export const getSourceResponse = serviceResponse.merge(
  z.object({
    source: source.nullable().optional(),
  }),
);

export type GetSourceParams = z.infer<typeof getSourceParams>;
export type GetSourceRequest = z.infer<typeof getSourceRequest>;
export type GetSourceResponse = z.infer<typeof getSourceResponse>;

/** ******************************************************************************
*  List Sources
******************************************************************************* */

export const listSourcesParams = z.object({
  archived: z.boolean().optional(),
});

export const listSourcesRequest = authedServiceRequest.merge(
  z.object({
    params: listSourcesParams.optional(),
  }),
);

export const listSourcesResponse = serviceResponse.merge(
  z.object({
    sources: z.array(source).optional(),
  }),
);

export type ListSourcesParams = z.infer<typeof listSourcesParams>;
export type ListSourcesRequest = z.infer<typeof listSourcesRequest>;
export type ListSourcesResponse = z.infer<typeof listSourcesResponse>;

/** ******************************************************************************
*  Source Import Info
******************************************************************************* */

export const getSourceImportInfoParams = z.object({
  importUrl: z.string(),
  type: zSourceTypes,
});

export const getSourceImportInfoRequest = authedServiceRequest.merge(
  z.object({
    params: getSourceImportInfoParams,
  }),
);

export const getSourceImportInfoResponse = serviceResponse.merge(
  z.object({
    info: sourceImportInfo.optional(),
  }),
);

export type GetSourceImportInfoParams = z.infer<typeof getSourceImportInfoParams>;
export type GetSourceImportInfoRequest = z.infer<typeof getSourceImportInfoRequest>;
export type GetSourceImportInfoResponse = z.infer<typeof getSourceImportInfoResponse>;