export interface ModelScalarValue<TType extends string, TValue> {
  type: TType;
  value: TValue;
}

export interface ModelManyRelationValue<TType extends string> {
  type: TType;
  nodeIds: string[];
  nodeRefersBackBy?: string;
}

export interface ModelOneRelationValue<TType extends string> {
  type: TType;
  nodeId: string[];
  nodeRefersBackBy?: string;
}

export type ModelBooleanValue = ModelScalarValue<"boolean", boolean>;
export type ModelStringValue = ModelScalarValue<"string", string>;
export type ModelNumberValue = ModelScalarValue<"number", number>;
export type ModelDateValue = ModelScalarValue<"date", Date>;
export type ModelJsonValue = ModelScalarValue<"json", object>;
export type ModelBelongsToManyValue = ModelManyRelationValue<'belongsToMany'>;
export type ModelBelongsToOneValue = ModelManyRelationValue<'belongsToOne'>;
export type ModelHasManyValue = ModelManyRelationValue<'hasMany'>;
export type ModelHasOneValue = ModelManyRelationValue<'hasOne'>;

export type ModelValue =
  | ModelStringValue
  | ModelNumberValue
  | ModelBooleanValue
  | ModelDateValue
  | ModelBelongsToManyValue
  | ModelBelongsToOneValue
  | ModelHasManyValue
  | ModelHasOneValue;

export interface Model {
  platformKeys: string[];
  domain: string;
  id: string;
  createdAt: Date;
  createdBy: string;
  updatedAt: Date;
  updatedBy: string;
  isDeleted: boolean;
  fields: Record<string, ModelValue>;
}

export interface ModelCreateOptions {
  platformKeys: string[];
  domain: string;
  createdBy: string;
  isDeleted?: boolean;
  fields: Record<string, ModelValue>;
}

export interface ModelUpdateOptions {
  id: string;
  updatedBy: string;
  isDeleted?: boolean;
  fields?: Record<string, ModelValue>;
}

export interface ModelPlatformsFilter {
  contains?: string;
  notContains?: string;
  equalTo?: string[];
  notEqualTo?: string[];
  containsAll?: string[];
  notContainsAll?: string[];
  containsAny?: string[];
  notContainsAny?: string[];
}

export interface ModelCommonFilter<TType extends string, TValue> {
  type: TType;
  equalTo?: TValue;
  notEqualTo?: TValue;
  oneOf?: Array<TValue | undefined>;
  notOneOf?: Array<TValue | undefined>;
  isNull?: boolean;
}

export interface ModelStringFilter extends ModelCommonFilter<"string", string> {
  contains?: string;
  notContains?: string;
  containsAny?: string[];
  notContainsAny?: string[];
  containsAll?: string[];
  notContainsAll?: string[];
  startsWith?: string;
  notStartsWith?: string;
  startsWithAny?: string[];
  notStartsWithAny?: string[];
  endsWith?: string;
  notEndsWith?: string;
  endsWithAny?: string[];
  notEndsWithAny?: string[];
  iContains?: string;
  iNotContains?: string;
  iContainsAny?: string[];
  iNotContainsAny?: string[];
  iContainsAll?: string[];
  iNotContainsAll?: string[];
  iStartsWith?: string;
  iNotStartsWith?: string;
  iStartsWithAny?: string[];
  iNotStartsWithAny?: string[];
  iEndsWith?: string;
  iNotEndsWith?: string;
  iEndsWithAny?: string[];
  iNotEndsWithAny?: string[];
  match?: string;
  notMatch?: string;
  matchAny?: string[];
  notMatchAny?: string[];
  matchAll?: string[];
  notMatchAll?: string[];
}

export type ModelBooleanFilter = ModelCommonFilter<"boolean", boolean>;

export type ModelNumberFilter = ModelCommonFilter<"number", number> & {
  greaterThanOrEqualTo?: number;
  greaterThan?: number;
  lessThanOrEqualTo?: number;
  lessThan?: number;
  integerPartEqualTo?: number;
  integerPartNotEqualTo?: number;
  integerPartOneOf?: number[];
  integerPartNotOneOf?: number[];
  integerPartGreaterThanOrEqualTo?: number;
  integerPartGreaterThan?: number;
  integerPartLessThanOrEqualTo?: number;
  integerPartLessThan?: number;
  fractionalPartEqualTo?: number;
  fractionalPartNotEqualTo?: number;
  fractionalPartOneOf?: number[];
  fractionalPartNotOneOf?: number[];
  fractionalPartGreaterThanOrEqualTo?: number;
  fractionalPartGreaterThan?: number;
  fractionalPartLessThanOrEqualTo?: number;
  fractionalPartLessThan?: number;
  roundedEqualTo?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
  roundedNotEqualTo?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
  roundedOneOf?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    values: number[];
  };
  roundedNotOneOf?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    values: number[];
  };
  roundedGreaterThanOrEqualTo?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
  roundedGreaterThan?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
  roundedLessThanOrEqualTo?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
  roundedLessThan?: {
    type: "floor" | "ceil" | "round";
    precision?: number;
    value: number;
  };
};

export type ModelDateFilter = ModelCommonFilter<"date", Date> & {
  greaterThanOrEqualTo?: Date;
  greaterThan?: Date;
  lessThanOrEqualTo?: Date;
  lessThan?: Date;
  dateEqualTo?: Date;
  dateNotEqualTo?: Date;
  dateOneOf?: Date[];
  dateNotOneOf?: Date[];
  dateGreaterThanOrEqualTo?: Date;
  dateGreaterThan?: Date;
  dateLessThanOrEqualTo?: Date;
  dateLessThan?: Date;
  timeEqualTo?: Date;
  timeNotEqualTo?: Date;
  timeOneOf?: Date[];
  timeNotOneOf?: Date[];
  timeGreaterThanOrEqualTo?: Date;
  timeGreaterThan?: Date;
  timeLessThanOrEqualTo?: Date;
  timeLessThan?: Date;
  yearEqualTo?: Date;
  yearNotEqualTo?: Date;
  yearOneOf?: Date[];
  yearNotOneOf?: Date[];
  yearGreaterThanOrEqualTo?: Date;
  yearGreaterThan?: Date;
  yearLessThanOrEqualTo?: Date;
  yearLessThan?: Date;
  monthEqualTo?: Date;
  monthNotEqualTo?: Date;
  monthOneOf?: Date[];
  monthNotOneOf?: Date[];
  monthGreaterThanOrEqualTo?: Date;
  monthGreaterThan?: Date;
  monthLessThanOrEqualTo?: Date;
  monthLessThan?: Date;
  dayEqualTo?: Date;
  dayNotEqualTo?: Date;
  dayOneOf?: Date[];
  dayNotOneOf?: Date[];
  dayGreaterThanOrEqualTo?: Date;
  dayGreaterThan?: Date;
  dayLessThanOrEqualTo?: Date;
  dayLessThan?: Date;
  hoursEqualTo?: Date;
  hoursNotEqualTo?: Date;
  hoursOneOf?: Date[];
  hoursNotOneOf?: Date[];
  hoursGreaterThanOrEqualTo?: Date;
  hoursGreaterThan?: Date;
  hoursLessThanOrEqualTo?: Date;
  hoursLessThan?: Date;
  minutesEqualTo?: Date;
  minutesNotEqualTo?: Date;
  minutesOneOf?: Date[];
  minutesNotOneOf?: Date[];
  minutesGreaterThanOrEqualTo?: Date;
  minutesGreaterThan?: Date;
  minutesLessThanOrEqualTo?: Date;
  minutesLessThan?: Date;
  secondsEqualTo?: Date;
  secondsNotEqualTo?: Date;
  secondsOneOf?: Date[];
  secondsNotOneOf?: Date[];
  secondsGreaterThanOrEqualTo?: Date;
  secondsGreaterThan?: Date;
  secondsLessThanOrEqualTo?: Date;
  secondsLessThan?: Date;
  millisecondsEqualTo?: Date;
  millisecondsNotEqualTo?: Date;
  millisecondsOneOf?: Date[];
  millisecondsNotOneOf?: Date[];
  millisecondsGreaterThanOrEqualTo?: Date;
  millisecondsGreaterThan?: Date;
  millisecondsLessThanOrEqualTo?: Date;
  millisecondsLessThan?: Date;
};

export type ModelJsonFilter = ModelCommonFilter<"json", object>;

export interface ModelCommonRelationValueFilter<TType extends string> {
  type: TType;
  contains?: string;
  notContains?: string;
  containsAll?: string[];
  notContainsAll?: string[];
  containsAny?: string[];
  notContainsAny?: string[];
  equalTo?: string[];
  notEqualTo?: string[];
}

export type ModelBelongsToRelationValueFilter = ModelCommonRelationValueFilter<
  "belongsTo"
> & {
  treeContains?: {
    refersToParentBy: string;
    value: string;
  };

  treeNotContains?: {
    refersToParentBy: string;
    value: string;
  };

  treeContainsAll?: {
    refersToParentBy: string;
    values: string[];
  };

  treeNotContainsAll?: {
    refersToParentBy: string;
    values: string[];
  };

  treeContainsAny?: {
    refersToParentBy: string;
    values: string[];
  };

  treeNotContainsAny?: {
    refersToParentBy: string;
    values: string[];
  };

  treeEqualTo?: {
    refersToParentBy: string;
    values: string[];
  };

  treeNotEqualTo?: {
    refersToParentBy: string;
    values: string[];
  };
};

export type ModelHasRelationValueFilter = ModelCommonRelationValueFilter<"has"> & {
  treeContains?: {
    refersToChildrenBy: string;
    value: string;
  };

  treeNotContains?: {
    refersToChildrenBy: string;
    value: string;
  };

  treeContainsAll?: {
    refersToChildrenBy: string;
    values: string[];
  };

  treeNotContainsAll?: {
    refersToChildrenBy: string;
    values: string[];
  };

  treeContainsAny?: {
    refersToChildrenBy: string;
    values: string[];
  };

  treeNotContainsAny?: {
    refersToChildrenBy: string;
    values: string[];
  };

  treeEqualTo?: {
    refersToChildrenBy: string;
    values: string[];
  };

  treeNotEqualTo?: {
    refersToChildrenBy: string;
    values: string[];
  };
};

export type ModelValueFilter =
  | ModelBooleanFilter
  | ModelStringFilter
  | ModelNumberFilter
  | ModelDateFilter
  | ModelJsonFilter
  | ModelBelongsToRelationValueFilter
  | ModelHasRelationValueFilter;

export type ModelFilters = {
  platformKeys?: ModelPlatformsFilter;
  domain?: ModelStringFilter;
  id?: ModelStringFilter;
  createdAt?: ModelDateFilter;
  createdBy?: ModelStringFilter;
  updatedAt?: ModelDateFilter;
  updatedBy?: ModelStringFilter;
  isDeleted?: ModelBooleanFilter;
  fields?: Record<string, ModelValueFilter>;
};

export type ModelSorting = Record<string, 'asc' | 'desc'>;

export type ModelSlicing = {
  offset?: number;
  limit?: number;
};