import z from 'zod';
import {
  authedServiceRequest,
  serviceRequest,
  serviceResponse,
} from '../interfaces/common';
import { metadata } from '../interfaces/Metadata';

export const zSyncTypes = z.enum([
  'Initial',
  'Manual',
  'Automatic',
]);

export const zSyncStatus = z.enum([
  'Pending',
  'Running',
  'Complete',
  'Failed',
]);

export const syncInfo = z.object({
  total: z.number(),
  new: z.number(),
  existing: z.number(),
  removed: z.number(),
  pending: z.number(),
  running: z.number(),
  completed: z.number(),
  failed: z.number(),
});

export const updateSyncInfoParams = z.object({
  total: z.number().optional(),
  new: z.number().optional(),
  existing: z.number().optional(),
  removed: z.number().optional(),
  pending: z.number().optional(),
  running: z.number().optional(),
  completed: z.number().optional(),
  failed: z.number().optional(),
});

export const sync = z.object({
  _id: z.string(),
  organizationId: z.string(),
  sourceId: z.string(),
  type: zSyncTypes,
  status: zSyncStatus,
  message: z.string().optional(),
  info: syncInfo,
  meta: metadata,
});

export type Sync = z.infer<typeof sync>;
export type SyncInfo = z.infer<typeof syncInfo>;
export type SyncTypes = z.infer<typeof zSyncTypes>;
export type SyncStatus = z.infer<typeof zSyncStatus>;

export interface SyncService {
  create(request: CreateSyncRequest): Promise<CreateSyncResponse>;
  update(request: UpdateSyncRequest): Promise<UpdateSyncResponse>;
  get(request: GetSyncRequest): Promise<GetSyncResponse>;
  latest(request: LatestSyncRequest): Promise<LatestSyncResponse>;
  list(request: ListSyncsRequest): Promise<ListSyncsResponse>;
}

/** ******************************************************************************
*  Create Sync
******************************************************************************* */

export const createSyncParams = z.object({
  sourceId: z.string(),
  type: zSyncTypes,
});

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

export const createSyncResponse = serviceResponse.merge(
  z.object({
    sync: sync.optional(),
  }),
);

export type CreateSyncParams = z.infer<typeof createSyncParams>;
export type CreateSyncRequest = z.infer<typeof createSyncRequest>;
export type CreateSyncResponse = z.infer<typeof createSyncResponse>;

/** ******************************************************************************
*  Update Sync
******************************************************************************* */

export const updateSyncParams = z.object({
  _id: z.string(),
  status: zSyncStatus.nullable().optional(),
  message: z.string().nullable().optional(),
  infoDiff: updateSyncInfoParams.optional(),
});

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

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

export type UpdateSyncParams = z.infer<typeof updateSyncParams>;
export type UpdateSyncRequest = z.infer<typeof updateSyncRequest>;
export type UpdateSyncResponse = z.infer<typeof updateSyncResponse>;

/** ******************************************************************************
*  Get Sync
******************************************************************************* */

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

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

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

export type GetSyncParams = z.infer<typeof getSyncParams>;
export type GetSyncRequest = z.infer<typeof getSyncRequest>;
export type GetSyncResponse = z.infer<typeof getSyncResponse>;

/** ******************************************************************************
*  Latest Sync
******************************************************************************* */

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

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

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

export type LatestSyncParams = z.infer<typeof latestSyncParams>;
export type LatestSyncRequest = z.infer<typeof latestSyncRequest>;
export type LatestSyncResponse = z.infer<typeof latestSyncResponse>;

/** ******************************************************************************
*  List Syncs
******************************************************************************* */

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

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

export const listSyncsResponse = serviceResponse.merge(
  z.object({
    syncs: z.array(sync).optional(),
  }),
);

export type ListSyncsParams = z.infer<typeof listSyncsParams>;
export type ListSyncsRequest = z.infer<typeof listSyncsRequest>;
export type ListSyncsResponse = z.infer<typeof listSyncsResponse>;