generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["fullTextSearch", "orderByNulls", "filteredRelationCount", "fieldReference"]
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

enum ServerType {
  SUBSONIC
  JELLYFIN
  NAVIDROME
}

enum ServerPermissionType {
  ADMIN
  EDITOR
  VIEWER
}

enum ExternalSource {
  MUSICBRAINZ
  LASTFM
  THEAUDIODB
  SPOTIFY
}

enum ExternalType {
  ID
  LINK
}

enum ImageType {
  PRIMARY
  BACKDROP
  LOGO
  SCREENSHOT
}

enum TaskType {
  FULL_SCAN
  QUICK_SCAN
  REFRESH
  SPOTIFY
  MUSICBRAINZ
  LASTFM
}

model RefreshToken {
  id    String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  token String @unique

  User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid
}

model User {
  id          String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  displayName String?  @unique
  username    String   @unique
  password    String
  enabled     Boolean  @default(false)
  isAdmin     Boolean  @default(false)
  deviceId    String   @unique
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  histories          History[]
  albumArtistRatings AlbumArtistRating[]
  artistRatings      ArtistRating[]
  albumRatings       AlbumRating[]
  songRatings        SongRating[]
  refreshTokens      RefreshToken[]

  serverFolderPermissions ServerFolderPermission[]
  serverPermissions       ServerPermission[]
  albumArtistFavorites    AlbumArtistFavorite[]
  artistFavorites         ArtistFavorite[]
  albumFavorites          AlbumFavorite[]
  songFavorites           SongFavorite[]
  userServerUrls          UserServerUrl[]
  tasks                   Task[]
}

model History {
  id String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid

  songs Song[]

  User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid
}

model Server {
  id           String     @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name         String
  url          String     @unique
  remoteUserId String
  username     String
  token        String
  noCredential Boolean    @default(true)
  type         ServerType
  createdAt    DateTime   @default(now())
  updatedAt    DateTime   @updatedAt

  albumArtists      AlbumArtist[]
  artists           Artist[]
  albums            Album[]
  songs             Song[]
  serverFolders     ServerFolder[]
  serverUrls        ServerUrl[]
  folders           Folder[]
  serverPermissions ServerPermission[]
  tasks             Task[]
  userServerUrls    UserServerUrl[]
}

model Folder {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name      String
  path      String   @unique
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  songs         Song[]
  serverFolders ServerFolder[]

  parentId String?  @db.Uuid
  parent   Folder?  @relation("FolderChildren", fields: [parentId], references: [id])
  children Folder[] @relation("FolderChildren")

  Server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, path], name: "uniqueFolderId")
}

model ServerPermission {
  id        String               @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  type      ServerPermissionType
  createdAt DateTime             @default(now())
  updatedAt DateTime             @updatedAt

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [userId, serverId], name: "uniqueServerPermissionsId")
}

model ServerUrl {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  url       String
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  server         Server          @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId       String          @db.Uuid
  userServerUrls UserServerUrl[]

  @@unique(fields: [serverId, url], name: "uniqueServerUrlId")
}

model UserServerUrl {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  serverUrl   ServerUrl @relation(fields: [serverUrlId], references: [id], onDelete: Cascade)
  serverUrlId String    @db.Uuid

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [userId, serverId], name: "uniqueUserServerUrlId")
}

model ServerFolder {
  id            String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name          String
  remoteId      String    @unique
  enabled       Boolean   @default(true)
  lastScannedAt DateTime?
  createdAt     DateTime  @default(now())
  updatedAt     DateTime  @updatedAt
  deleted       Boolean   @default(false)

  albumArtists            AlbumArtist[]
  artists                 Artist[]
  albums                  Album[]
  songs                   Song[]
  folders                 Folder[]
  serverFolderPermissions ServerFolderPermission[]

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, remoteId], name: "uniqueServerFolderId")
}

model ServerFolderPermission {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id])
  userId String @db.Uuid

  serverFolder   ServerFolder @relation(fields: [serverFolderId], references: [id], onDelete: Cascade)
  serverFolderId String       @db.Uuid

  @@unique(fields: [userId, serverFolderId], name: "uniqueServerFolderPermissionsId")
}

model Genre {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name      String   @unique
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  albumArtists AlbumArtist[]
  artists      Artist[]
  albums       Album[]
  songs        Song[]
}

model AlbumArtistFavorite {
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  albumArtist   AlbumArtist @relation(fields: [albumArtistId], references: [id], onDelete: Cascade)
  albumArtistId String      @db.Uuid

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  @@id([userId, albumArtistId])
  @@unique(fields: [userId, albumArtistId], name: "uniqueAlbumArtistFavoriteId")
}

model ArtistFavorite {
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  artist   Artist @relation(fields: [artistId], references: [id], onDelete: Cascade)
  artistId String @db.Uuid

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  @@id([userId, artistId])
  @@unique(fields: [userId, artistId], name: "uniqueArtistFavoriteId")
}

model AlbumFavorite {
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  album   Album  @relation(fields: [albumId], references: [id], onDelete: Cascade)
  albumId String @db.Uuid

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  @@id([userId, albumId])
  @@unique(fields: [userId, albumId], name: "uniqueAlbumFavoriteId")
}

model SongFavorite {
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  song   Song   @relation(fields: [songId], references: [id], onDelete: Cascade)
  songId String @db.Uuid

  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId String @db.Uuid

  @@id([userId, songId])
  @@unique(fields: [userId, songId], name: "uniqueSongFavoriteId")
}

model AlbumArtistRating {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  value     Float
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id])
  userId String @db.Uuid

  albumArtist   AlbumArtist @relation(fields: [albumArtistId], references: [id])
  albumArtistId String      @db.Uuid

  @@unique(fields: [userId, albumArtistId], name: "uniqueAlbumArtistRatingId")
}

model ArtistRating {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  value     Float
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id])
  userId String @db.Uuid

  artist   Artist @relation(fields: [artistId], references: [id])
  artistId String @db.Uuid

  @@unique(fields: [userId, artistId], name: "uniqueArtistRatingId")
}

model AlbumRating {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  value     Float
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id])
  userId String @db.Uuid

  album   Album  @relation(fields: [albumId], references: [id])
  albumId String @db.Uuid

  @@unique(fields: [userId, albumId], name: "uniqueAlbumRatingId")
}

model SongRating {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  value     Float
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  user   User   @relation(fields: [userId], references: [id])
  userId String @db.Uuid

  song   Song   @relation(fields: [songId], references: [id])
  songId String @db.Uuid

  @@unique(fields: [userId, songId], name: "uniqueSongRatingId")
}

model Image {
  id        String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  url       String?
  remoteUrl String
  type      ImageType
  createdAt DateTime  @default(now())
  updatedAt DateTime  @updatedAt

  albumArtists AlbumArtist[]
  artists      Artist[]
  albums       Album[]
  songs        Song[]

  @@unique(fields: [remoteUrl, type], name: "uniqueImageId")
}

model External {
  id        String         @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  value     String
  type      ExternalType
  source    ExternalSource
  createdAt DateTime       @default(now())
  updatedAt DateTime       @updatedAt

  albumArtists AlbumArtist[]
  artists      Artist[]
  albums       Album[]
  songs        Song[]

  @@unique(fields: [value, source], name: "uniqueExternalId")
}

model AlbumArtist {
  id              String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name            String
  sortName        String
  biography       String?
  remoteId        String
  remoteCreatedAt DateTime?
  deleted         Boolean   @default(false)
  createdAt       DateTime  @default(now())
  updatedAt       DateTime  @updatedAt

  albums               Album[]
  genres               Genre[]
  externals            External[]
  serverFolders        ServerFolder[]
  ratings              AlbumArtistRating[]
  images               Image[]
  songs                Song[]
  albumArtistFavorites AlbumArtistFavorite[]

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, remoteId], name: "uniqueAlbumArtistId")
}

model Album {
  id              String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name            String
  sortName        String
  releaseDate     DateTime?
  releaseYear     Int?
  remoteId        String
  remoteCreatedAt DateTime?
  deleted         Boolean   @default(false)
  createdAt       DateTime  @default(now())
  updatedAt       DateTime  @updatedAt

  songs         Song[]
  genres        Genre[]
  artists       Artist[]
  albumArtists  AlbumArtist[]
  externals     External[]
  serverFolders ServerFolder[]
  ratings       AlbumRating[]
  images        Image[]
  favorites     AlbumFavorite[]

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, remoteId], name: "uniqueAlbumId")
}

model Artist {
  id              String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name            String
  sortName        String
  biography       String?
  remoteId        String
  remoteCreatedAt DateTime?
  deleted         Boolean   @default(false)
  createdAt       DateTime  @default(now())
  updatedAt       DateTime  @updatedAt

  genres        Genre[]
  albums        Album[]
  songs         Song[]
  externals     External[]
  serverFolders ServerFolder[]
  ratings       ArtistRating[]
  images        Image[]
  favorites     ArtistFavorite[]

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, remoteId], name: "uniqueArtistId")
}

model Song {
  id              String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  name            String
  sortName        String
  releaseDate     DateTime?
  releaseYear     Int?
  duration        Float
  size            Int?
  lyrics          String?
  bitRate         Int
  container       String
  discNumber      Int       @default(1)
  trackNumber     Int?
  artistName      String?
  remoteId        String
  remoteCreatedAt DateTime?
  skip            Boolean   @default(false)
  deleted         Boolean   @default(false)
  createdAt       DateTime  @default(now())
  updatedAt       DateTime  @updatedAt

  genres        Genre[]
  artists       Artist[]
  externals     External[]
  folders       Folder[]
  serverFolders ServerFolder[]
  histories     History[]
  ratings       SongRating[]
  images        Image[]
  favorites     SongFavorite[]

  albumArtist   AlbumArtist? @relation(fields: [albumArtistId], references: [id])
  albumArtistId String?      @db.Uuid

  album   Album?  @relation(fields: [albumId], references: [id])
  albumId String? @db.Uuid

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  @@unique(fields: [serverId, remoteId], name: "uniqueSongId")
}

model Task {
  id        String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  type      TaskType
  message   String?
  completed Boolean  @default(false)
  isError   Boolean  @default(false)
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  server   Server @relation(fields: [serverId], references: [id], onDelete: Cascade)
  serverId String @db.Uuid

  user   User?   @relation(fields: [userId], references: [id])
  userId String? @db.Uuid
}