/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
/** @packageDocumentation
 * @module Schema
 */
import { IModelStatus } from "@itwin/core-bentley";
import { IModelError } from "@itwin/core-common";
import { ClassRegistry } from "./ClassRegistry";
import { ECVersion, SchemaKey } from "@itwin/ecschema-metadata";
/** Base class for all schema classes - see [working with schemas and elements in TypeScript]($docs/learning/backend/SchemasAndElementsInTypeScript.md).
 *
 * When subclassing from Schema, it is good practice to follow this pattern:
 *
 * ```typescript
 * class MyCustomSchema extends Schema {
 *   public static override get schemaName(): string { return "MyCustomSchema"; }
 *   public static get classes(): typeof Entity[] {
 *     return [MyOwnECClass, AnotherECClass];
 *   }
 *   public static registerSchema() {
 *     if (this !== Schemas.getRegisteredSchema(this.schemaName)) {
 *       Schemas.unregisterSchema(this.schemaName);
 *       Schemas.registerSchema(this);
 *       for (const ecClass of this.classes) {
 *         ClassRegistry.register(ecClass, this);
 *       }
 *     }
 *   }
 *
 *   public static unregisterSchema() {
 *     Schemas.unregisterSchema(this.schemaName);
 *   }
 * }
 * ```
 *
 * @public
 */
export class Schema {
    /** The name of the BIS schema handled by this Schema.
     * @note Every subclass of Schema ** MUST ** override this method to identify its BIS schema.
     * Failure to do so will ordinarily result in an error when the schema is registered, since there may only
     * be one JavaScript class for a given BIS schema (usually the errant schema will collide with its superclass.)
     */
    static get schemaName() { throw new Error(`you must override static schemaName in ${this.name}`); }
    /** Unique identifier for this schema, typed variant of [[schemaName]].
     * @internal
     */
    static get schemaKey() {
        // We cannot cache this here because the schemaName may be overridden without this being overridden
        return new SchemaKey(this.schemaName, ECVersion.NO_VERSION); // backend cares little for versions right now, as only one version can exist in an imodel
    }
    /** if true, this Schema is a proxy for a missing Domain marked with the `BisCore.SchemaHasBehavior` customAttribute.
     * Classes generated for this Schema will disallow protected operations.
     * @internal
     */
    static get missingRequiredBehavior() { return false; }
    /** Get a semver-compatible string from a padded version string.
     * works on unpadded version strings as well
     * if there is no write version, it will be added
     * @example Schema.toSemverString("1.02.03") === "1.2.3"
     * @example Schema.toSemverString("1.01") === "1.0.1" // write version was added
     * @beta
     */
    static toSemverString(paddedVersion) {
        const tuple = paddedVersion.split(".").map(Number);
        const noWriteVersion = tuple.length === 2;
        if (noWriteVersion)
            tuple.splice(1, 0, 0); // insert 0 before the second element
        return tuple.join(".");
    }
    /** Schemas may not be instantiated. The method is not private only because that precludes subclassing. It throws an
     * error if it is ever called.
     * @internal
     */
    constructor() { throw new Error(`cannot create an instance of a Schema ${this.constructor.name}`); }
}
/**
 * Holds a map of registered schemas.
 * @public
 */
export class SchemaMap {
    _schemas = new Map();
    /** @internal */
    get(schemaName) {
        return this._schemas.get(schemaName.toLowerCase());
    }
    /** @internal */
    set(schemaName, schema) {
        this._schemas.set(schemaName.toLowerCase(), schema);
    }
    /** @internal */
    delete(schemaName) {
        return this._schemas.delete(schemaName.toLowerCase());
    }
    /** Register a schema prior to using it.
     * @throws [[IModelError]] if a schema of the same name is already registered.
     * @public
     */
    registerSchema(schema) {
        const key = schema.schemaName.toLowerCase();
        if (this.get(key))
            throw new IModelError(IModelStatus.DuplicateName, `Schema "${schema.schemaName}" is already registered`);
        this.set(key, schema);
    }
}
/** Manages registered schemas
 * @public
 */
export class Schemas {
    static _globalSchemas = new SchemaMap();
    constructor() { } // this is a singleton
    /** Register a schema prior to using it.
     * This method registers the schema globally, to register a schema within the scope of a single iModel, use `IModelDb.schemaMap`.
     * @throws [[IModelError]] if a schema of the same name is already registered.
     */
    static registerSchema(schema) {
        this._globalSchemas.registerSchema(schema);
    }
    /** Unregister a schema, by name, if one is already registered.
     * This function is not normally needed, but is useful for cases where a generated *proxy* schema needs to be replaced by the *real* schema.
     * @param schemaName Name of the schema to unregister
     * @return true if the schema was unregistered
     */
    static unregisterSchema(schemaName) {
        const schema = this.getRegisteredSchema(schemaName);
        if (undefined !== schema)
            ClassRegistry.unregisterClassesFrom(schema);
        return this._globalSchemas.delete(schemaName.toLowerCase());
    }
    /** Look up a previously registered schema
     * @param schemaName The name of the schema
     * @returns the previously registered schema or undefined if not registered.
     */
    static getRegisteredSchema(schemaName) { return this._globalSchemas.get(schemaName.toLowerCase()); }
}
//# sourceMappingURL=Schema.js.map