import faker from '@faker-js/faker';

const arrayOf = <T>(f: () => T) => {
  const length = 3;

  return Array.from({
    length,
  }, f);
};

const objectOf = <T>(f: () => T) => {
  const keys = ['foo', 'bar', 'qux'];

  return keys.reduce<Record<string, T>>((object, key) => {
    object[key] = f();
    return object;
  }, {});
};

const factories = {
  boolean: () => faker.datatype.boolean(),
  date_iso_8601: () => faker.datatype.datetime().toISOString().slice(0, 10),
  date_time_iso_8601: () => faker.datatype.datetime().toISOString(),
  decimal: () => faker.datatype.float(),
  double: () => faker.datatype.float(),
  integer: () => faker.datatype.number(),
  json: () => faker.datatype.json(),
  long: () => faker.datatype.number(),
  object: () => faker.datatype.json(),
  string: () => faker.datatype.string(),
  unit: () => undefined,
  uuid: () => faker.datatype.uuid(),
  'namespace.enums.app_sort_by': (): namespace.enums.AppSortBy => faker.helpers.arrayElement(['name', 'created_at', 'updated_at', 'competition_status']),
  'namespace.enums.competition_status': (): namespace.enums.CompetitionStatus => faker.helpers.arrayElement(['pending', 'active', 'closed']),
  'namespace.enums.sort_order': (): namespace.enums.SortOrder => faker.helpers.arrayElement(['asc', 'desc']),
  'namespace.enums.vote_type': (): namespace.enums.VoteType => faker.helpers.arrayElement(['basic', 'premium']),

  'namespace.models.competition': (): namespace.models.Competition => ({
    guid: factories.uuid(),
    name: factories.string(),
    status: factories['namespace.enums.competition_status'](),
    start_at: factories.date_time_iso_8601(),
    end_at: factories.date_time_iso_8601(),
    created_at: factories.date_time_iso_8601(),
    updated_at: factories.date_time_iso_8601(),
  }),

  'namespace.models.competition_participant': (): namespace.models.CompetitionParticipant => ({
    guid: factories.uuid(),
    competition_id: factories.uuid(),
    competitor_id: factories.uuid(),
  }),

  'namespace.models.competitor': (): namespace.models.Competitor => ({
    guid: factories.uuid(),
    name: factories.string(),
  }),

  'namespace.models.vote': (): namespace.models.Vote => ({
    guid: factories.uuid(),
    competition_participant_id: factories.uuid(),
    voter_id: factories.uuid(),
    type: factories.string(),
    points: factories.integer(),
  }),

  'namespace.models.voter': (): namespace.models.Voter => ({
    guid: factories.uuid(),
    name: factories.string(),
    asdf: factories.string(),
  }),
};

export const makeAppSortBy = () => factories['namespace.enums.app_sort_by']();
export const makeCompetition = () => factories['namespace.models.competition']();
export const makeCompetitionParticipant = () => factories['namespace.models.competition_participant']();
export const makeCompetitionStatus = () => factories['namespace.enums.competition_status']();
export const makeCompetitor = () => factories['namespace.models.competitor']();
export const makeSortOrder = () => factories['namespace.enums.sort_order']();
export const makeVote = () => factories['namespace.models.vote']();
export const makeVoteType = () => factories['namespace.enums.vote_type']();
export const makeVoter = () => factories['namespace.models.voter']();