rules.bolt

type Matrix<Type> extends Map<Index, Map<Index, Type>> {}
type Presence<Type> extends Map<Type, Boolean> {}
type CurrentUser extends UserId {
  validate() { return isCurrentUser(this)}
}

isCurrentUser(userId) {
  return auth != null && auth.uid == userId;
}

type Clues {
    across: Matrix<String>
    down: Matrix<String>
}

type Crossword {
    rows: Number
    symmetric: Boolean
    themeEntries: Boolean[]
    // Looks like a gap in Bolt where it doesn't notice that the value can be null
    // so without specifying `| Null` here explicity, it will add a validation to require
    // the children
    clues: Clues | Null
    boxes: Matrix<Box>
    title: String | Null

    read() {
        auth.uid == root.permissions[key()].owner ||
        root.permissions[key()].collaborators[auth.uid] ||
        root.permissions[key()].global
    }

    create() {
        auth.uid == root.permissions[key()].owner &&
        root.users[auth.uid].crosswords[key()] != null
    }

    delete() {
        auth.uid == root.permissions[key()].owner
    }

    update() {
        !root.permissions[key()].readonly && (
            auth.uid == root.permissions[key()].owner ||
            root.permissions[key()].collaborators[auth.uid] ||
            root.permissions[key()].global
        )
    }
}

type Index extends String {
    validate() {
        this.test(/^[0-9]+$/)
    }
}

type Direction extends String {
    validate() {
        this.test(/(across|down)/)
    }
}

type Box {
    blocked: Boolean | Null,
    circled: Boolean | Null,
    shaded: Boolean | Null,
    content: String | Null,
}

path /crosswords is Crossword[] {}

type CrosswordMetadata {
    title: String | Null,
}

type WordlistEntry {
    word: String,
    usedBy: Presence<CrosswordId>,
}

type User {
    crosswords: CrosswordMetadata[],
    wordlist: WordlistEntry[],

    write() {
        key() == auth.uid
    }
    read() {
        key() == auth.uid
    }
}

path /users is User[] {}

type Permissions {
    // currently this can be Null when `global` is true
    // but we should make that explicit
    owner: UserId,
    collaborators: Presence<UserId>,
    global: Boolean | Null,
    readonly: Boolean | Null,

    create() {
        auth.uid != null &&
        auth.uid == this.owner &&
        root.crosswords[key()] != null
    }
    update() {
        auth.uid == this.owner
    }
    delete() {
        auth.uid == this.owner
    }
    validate() {
        auth.token.isAdmin == true ||
        this.owner == auth.uid &&
        (
            prior(this.owner) == null ||
            this.owner == prior(this.owner)
        ) &&
        this.global == prior(this.global) &&
        this.readonly == prior(this.readonly)
    }
}

// would like to be able to ensure this user exists but we don't own that list
type UserId extends String {}

type CrosswordId extends String {
    validate() {
        root.crosswords[key()] != null
    }
}

path /permissions is Map<CrosswordId, Permissions> {}

/*
 * Cursors
 * Note: displayName, photoUrl, and color are populated by a cloud function.
 * They're marked as nullable here so that the client write of the other data is not blocked.
 * TODO: confirm that we there's no way to write a cloud function that lets
 * us mark them as non-nullable here
 */
type Cursor {
    userId: CurrentUser

    row: Number | Null
    column: Number | Null

    displayName: String | Null
    photoURL: String | Null
    color: String | Null

    write() {
        auth.uid == this.userId || auth.uid == prior(this.userId)
    }
}

// would rather specify the path this way, but then we can't access the cw id key
// from the cursor key object level
// path /cursors is Map<CrosswordId, Cursor[]> {
path /cursors/{cwid} is Cursor[] {
    validate() {
        root.crosswords[key()] != null
    }

    read() {
        auth.uid == root.permissions[cwid].owner ||
        root.permissions[cwid].collaborators[auth.uid] ||
        root.permissions[cwid].global
    }
}

type CommunalCrossword {
  current: CrosswordId

  archive: CrosswordId[]

  write() {
    return false;
  }
  read() {
    return true;
  }
}

path /communalCrossword is CommunalCrossword {}