import { and, eq, isNotNull, or, sql } from "drizzle-orm";
import {
  boolean,
  check,
  integer,
  jsonb,
  pgEnum,
  pgTable,
  primaryKey,
  text,
  timestamp,
} from "drizzle-orm/pg-core";

export const tangledProfile = pgTable(
  "tangled_profile",
  {
    did: text().primaryKey(),
    rev: text().notNull(),
    // no rkey here, because always self
    cid: text(),
    deleted: boolean().notNull(),

    avatar: text(),
    description: text(),
    links: text().array(),
    stats: text().array(),
    bluesky: boolean(),
    location: text(),
    pinnedRepositories: text().array(),
    pronouns: text(),
    preferredHandle: text(),
  },
  (table) => [
    check(
      "tangled_profile_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_profile_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.bluesky)))!,
    ),
  ],
);

export const tangledReaction = pgTable(
  "tangled_reaction",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    reaction: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_reaction_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_reaction_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.subject), isNotNull(table.reaction), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledStar = pgTable(
  "tangled_star",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    subjectDid: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_star_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_star_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledRefUpdate = pgTable(
  "tangled_ref_update",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    ref: text(),
    committerDid: text(),
    ownerDid: text(),
    repoDid: text(),
    repoName: text(),
    oldSha: text(),
    newSha: text(),
    metaIsDefaultRef: boolean(),
    metaLangBreakdown: jsonb(),
    metaCommitCount: jsonb(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_ref_update_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_ref_update_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.ref),
          isNotNull(table.committerDid),
          isNotNull(table.repoName),
          isNotNull(table.oldSha),
          isNotNull(table.newSha),
          isNotNull(table.metaIsDefaultRef),
          isNotNull(table.metaCommitCount),
        ),
      )!,
    ),
  ],
);

export const tangledFollow = pgTable(
  "tangled_follow",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_follow_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_follow_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.subject), isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledVouchKind = pgEnum("tangled_vouch_kind", ["vouch", "denounce"]);

export const tangledVouch = pgTable(
  "tangled_vouch",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    kind: tangledVouchKind(),
    reason: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_vouch_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_vouch_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.kind), isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledIssueComment = pgTable(
  "tangled_issue_comment",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    issue: text(),
    body: text(),
    createdAt: timestamp({ withTimezone: true }),
    replyTo: text(),
    mentions: text().array(),
    references: text().array(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_issue_comment_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_issue_comment_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.issue), isNotNull(table.body), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledIssue = pgTable(
  "tangled_issue",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    repo: text(),
    repoDid: text(),
    title: text(),
    body: text(),
    createdAt: timestamp({ withTimezone: true }),
    mentions: text().array(),
    references: text().array(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_issue_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_issue_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.title), isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledIssueState = pgTable(
  "tangled_issue_state",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    issue: text(),
    state: text(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_issue_state_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_issue_state_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.issue), isNotNull(table.state)))!,
    ),
  ],
);

export const tangledKnot = pgTable(
  "tangled_knot",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_knot_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_knot_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledKnotMember = pgTable(
  "tangled_knot_member",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    domain: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_knot_member_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_knot_member_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.subject), isNotNull(table.domain), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledLabelDefinition = pgTable(
  "tangled_label_definition",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    name: text(),
    valueType: text(),
    valueFormat: text(),
    valueEnum: text().array(),
    scope: text().array(),
    color: text(),
    createdAt: timestamp({ withTimezone: true }),
    multiple: boolean(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_label_definition_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_label_definition_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.name),
          isNotNull(table.valueType),
          isNotNull(table.valueFormat),
          isNotNull(table.scope),
          isNotNull(table.createdAt),
        ),
      )!,
    ),
  ],
);

export const tangledLabelOp = pgTable(
  "tangled_label_op",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    performedAt: timestamp({ withTimezone: true }),
    add: jsonb(),
    delete: jsonb(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_label_op_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_label_op_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.subject),
          isNotNull(table.add),
          isNotNull(table.delete),
          isNotNull(table.performedAt),
        ),
      )!,
    ),
  ],
);

export const tangledPipelineTriggerMetadataKind = pgEnum("tangled_pipeline_trigger_metadata_kind", [
  "push",
  "pull_request",
  "manual",
]);

export const tangledPipeline = pgTable(
  "tangled_pipeline",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    triggerMetadataKind: tangledPipelineTriggerMetadataKind(),
    triggerMetadataRepoKnot: text(),
    triggerMetadataRepoDid: text(),
    triggerMetadataRepoRepoDid: text(), // I know, confusing
    triggerMetadataRepoRepo: text(), // i know, I know,
    triggerMetadataRepoDefaultBranch: text(),
    triggerMetadataPushRef: text(),
    triggerMetadataPushNewSha: text(),
    triggerMetadataPushOldSha: text(),
    triggerMetadataPullSourceBranch: text(),
    triggerMetadataPullTargetBranch: text(),
    triggerMetadataPullSourceSha: text(),
    triggerMetadataPullAction: text(),
    triggerMetadataManual: jsonb(),

    workflows: jsonb(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_pipeline_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_pipeline_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.triggerMetadataKind),
          isNotNull(table.triggerMetadataRepoKnot),
          isNotNull(table.triggerMetadataRepoDid),
          isNotNull(table.triggerMetadataRepoDefaultBranch),
          isNotNull(table.workflows),
        ),
      )!,
    ),
  ],
);

export const tangledPipelineStatusStatus = pgEnum("tangled_pipeline_status_status", [
  "pending",
  "running",
  "failed",
  "timeout",
  "cancelled",
  "success",
]);

export const tangledPipelineStatus = pgTable(
  "tangled_pipeline_status",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    pipeline: text(),
    workflow: text(),
    status: tangledPipelineStatusStatus(),
    createdAt: timestamp({ withTimezone: true }),
    error: text(),
    exitCode: integer(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_pipeline_status_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_pipeline_status_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.pipeline),
          isNotNull(table.workflow),
          isNotNull(table.status),
          isNotNull(table.createdAt),
        ),
      )!,
    ),
  ],
);

export const tangledPublicKey = pgTable(
  "tangled_public_key",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    key: text(),
    name: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_public_key_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_public_key_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.key), isNotNull(table.name), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledPullComment = pgTable(
  "tangled_pull_comment",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    pull: text(),
    body: text(),
    createdAt: timestamp({ withTimezone: true }),
    mentions: text().array(),
    references: text().array(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_pull_comment_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_pull_comment_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.pull), isNotNull(table.body), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledPull = pgTable(
  "tangled_pull",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    title: text(),
    body: text(),
    rounds: jsonb(),
    sourceBranch: text(),
    sourceRepo: text(),
    sourceRepoDid: text(),
    targetBranch: text(),
    targetRepo: text(),
    targetRepoDid: text(),
    createdAt: timestamp({ withTimezone: true }),
    mentions: text().array(),
    references: text().array(),
    dependentOn: text(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_pull_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_pull_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.targetBranch),
          isNotNull(table.title),
          isNotNull(table.createdAt),
          isNotNull(table.rounds),
        ),
      )!,
    ),
  ],
);

export const tangledPullStatus = pgTable(
  "tangled_pull_status",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    pull: text(),
    status: text(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_pull_status_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_pull_status_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.pull), isNotNull(table.status)))!,
    ),
  ],
);

export const tangledArtifact = pgTable(
  "tangled_artifact",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    name: text(),
    repo: text(),
    repoDid: text(),
    tag: text(), // TODO: look into making this... bytes
    createdAt: timestamp({ withTimezone: true }),
    artifactRef: text(),
    artifactSize: integer(),
    artifactMimeType: text(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_artifact_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_artifact_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.name),
          isNotNull(table.tag),
          isNotNull(table.createdAt),
          isNotNull(table.artifactRef),
          isNotNull(table.artifactSize),
          isNotNull(table.artifactMimeType),
        ),
      )!,
    ),
  ],
);

export const tangledCollaborator = pgTable(
  "tangled_collaborator",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    repo: text(),
    repoDid: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_collaborator_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_collaborator_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.subject), isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledRepo = pgTable(
  "tangled_repo",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    name: text(),
    knot: text(),
    spindle: text(),
    description: text(),
    website: text(),
    topics: text().array(),
    source: text(),
    labels: text().array(),
    repoDid: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_repo_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_repo_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.name), isNotNull(table.knot), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledSpindleMember = pgTable(
  "tangled_spindle_member",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    subject: text(),
    instance: text(),
    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_spindle_member_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_spindle_member_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(isNotNull(table.subject), isNotNull(table.instance), isNotNull(table.createdAt)),
      )!,
    ),
  ],
);

export const tangledSpindle = pgTable(
  "tangled_spindle",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    createdAt: timestamp({ withTimezone: true }),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_spindle_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_spindle_non_null_fields",
      or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!,
    ),
  ],
);

export const tangledString = pgTable(
  "tangled_string",
  {
    did: text().notNull(),
    rev: text().notNull(),
    rkey: text().notNull(),
    cid: text(),
    deleted: boolean().notNull(),

    filename: text(),
    description: text(),
    createdAt: timestamp({ withTimezone: true }),
    contents: text(),
  },
  (table) => [
    primaryKey({ columns: [table.did, table.rkey] }),
    check(
      "tangled_string_cid_only_null_if_deleted",
      or(isNotNull(table.cid), eq(table.deleted, sql`true`))!,
    ),
    check(
      "tangled_string_non_null_fields",
      or(
        eq(table.deleted, sql`true`),
        and(
          isNotNull(table.filename),
          isNotNull(table.description),
          isNotNull(table.createdAt),
          isNotNull(table.contents),
        ),
      )!,
    ),
  ],
);