"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const immutable_1 = __importDefault(require("immutable"));
const logger_1 = __importDefault(require("../utils/logger"));
const fs_1 = __importDefault(require("./fs"));
const config_1 = __importDefault(require("./config"));
const readme_1 = __importDefault(require("./readme"));
const summary_1 = __importDefault(require("./summary"));
const glossary_1 = __importDefault(require("./glossary"));
const languages_1 = __importDefault(require("./languages"));
const ignore_1 = __importDefault(require("./ignore"));
class Book extends immutable_1.default.Record({
    // Logger for outptut message
    // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 0.
    logger: (0, logger_1.default)(),
    // Filesystem binded to the book scope to read files/directories
    fs: new fs_1.default(),
    // Ignore files parser
    ignore: new ignore_1.default(),
    // Structure files
    config: new config_1.default(),
    readme: new readme_1.default(),
    summary: new summary_1.default(),
    glossary: new glossary_1.default(),
    languages: new languages_1.default(),
    // ID of the language for language books
    language: String(),
    // List of children, if multilingual (String -> Book)
    books: immutable_1.default.OrderedMap()
}) {
    getLogger() {
        return this.get("logger");
    }
    getFS() {
        return this.get("fs");
    }
    getIgnore() {
        return this.get("ignore");
    }
    getConfig() {
        return this.get("config");
    }
    getReadme() {
        return this.get("readme");
    }
    getSummary() {
        return this.get("summary");
    }
    getGlossary() {
        return this.get("glossary");
    }
    getLanguages() {
        return this.get("languages");
    }
    getBooks() {
        return this.get("books");
    }
    getLanguage() {
        return this.get("language");
    }
    /**
     Return FS instance to access the content

     @return {FS}
     */
    getContentFS() {
        const fs = this.getFS();
        const config = this.getConfig();
        const rootFolder = config.getValue("root");
        if (rootFolder) {
            return fs_1.default.reduceScope(fs, rootFolder);
        }
        return fs;
    }
    /**
     Return root of the book

     @return {string}
     */
    getRoot() {
        const fs = this.getFS();
        return fs.getRoot();
    }
    /**
     Return root for content of the book

     @return {string}
     */
    getContentRoot() {
        const fs = this.getContentFS();
        return fs.getRoot();
    }
    /**
     Check if a file is ignore (should not being parsed, etc)

     @param {string} ref
     @return {Page|undefined}
     */
    isFileIgnored(filename) {
        const ignore = this.getIgnore();
        const language = this.getLanguage();
        // Ignore is always relative to the root of the main book
        if (language) {
            filename = path_1.default.join(language, filename);
        }
        return ignore.isFileIgnored(filename);
    }
    /**
     Check if a content file is ignore (should not being parsed, etc)

     @param {string} ref
     @return {Page|undefined}
     */
    isContentFileIgnored(filename) {
        const config = this.getConfig();
        const rootFolder = config.getValue("root");
        if (rootFolder) {
            filename = path_1.default.join(rootFolder, filename);
        }
        return this.isFileIgnored(filename);
    }
    /**
     Is this book the parent of language's books

     @return {boolean}
     */
    isMultilingual() {
        return this.getLanguages().getCount() > 0;
    }
    /**
     Return true if book is associated to a language

     @return {boolean}
     */
    isLanguageBook() {
        return Boolean(this.getLanguage());
    }
    /**
     Return a languages book

     @param {string} language
     @return {Book}
     */
    getLanguageBook(language) {
        const books = this.getBooks();
        return books.get(language);
    }
    /**
     Add a new language book

     @param {string} language
     @param {Book} book
     @return {Book}
     */
    addLanguageBook(language, book) {
        let books = this.getBooks();
        books = books.set(language, book);
        return this.set("books", books);
    }
    /**
     Set the summary for this book

     @param {Summary}
     @return {Book}
     */
    setSummary(summary) {
        return this.set("summary", summary);
    }
    /**
     Set the readme for this book

     @param {Readme}
     @return {Book}
     */
    setReadme(readme) {
        return this.set("readme", readme);
    }
    /**
     Set the configuration for this book

     @param {Config}
     @return {Book}
     */
    setConfig(config) {
        return this.set("config", config);
    }
    /**
     Set the ignore instance for this book

     @param {Ignore}
     @return {Book}
     */
    setIgnore(ignore) {
        return this.set("ignore", ignore);
    }
    /**
     Change log level

     @param {string} level
     @return {Book}
     */
    setLogLevel(level) {
        this.getLogger().setLevel(level);
        return this;
    }
    /**
     Create a book using a filesystem

     @param {FS} fs
     @return {Book}
     */
    static createForFS(fs) {
        return new Book({
            fs: fs
        });
    }
    /**
     Infers the default extension for files
     @return {string}
     */
    getDefaultExt() {
        // Inferring sources
        const clues = [this.getReadme(), this.getSummary(), this.getGlossary()];
        // List their extensions
        const exts = clues.map((clue) => {
            const file = clue.getFile();
            if (file.exists()) {
                return file.getParser().getExtensions().first();
            }
            else {
                return null;
            }
        });
        // Adds the general default extension
        exts.push(".md");
        // Choose the first non null
        return exts.find((e) => {
            return e !== null;
        });
    }
    /**
     Infer the default path for a Readme.
     @param {boolean} [absolute=false] False for a path relative to
     this book's content root
     @return {string}
     */
    getDefaultReadmePath(absolute) {
        const defaultPath = `README${this.getDefaultExt()}`;
        if (absolute) {
            return path_1.default.join(this.getContentRoot(), defaultPath);
        }
        else {
            return defaultPath;
        }
    }
    /**
     Infer the default path for a Summary.
     @param {boolean} [absolute=false] False for a path relative to
     this book's content root
     @return {string}
     */
    getDefaultSummaryPath(absolute) {
        const defaultPath = `SUMMARY${this.getDefaultExt()}`;
        if (absolute) {
            return path_1.default.join(this.getContentRoot(), defaultPath);
        }
        else {
            return defaultPath;
        }
    }
    /**
     Infer the default path for a Glossary.
     @param {boolean} [absolute=false] False for a path relative to
     this book's content root
     @return {string}
     */
    getDefaultGlossaryPath(absolute) {
        const defaultPath = `GLOSSARY${this.getDefaultExt()}`;
        if (absolute) {
            return path_1.default.join(this.getContentRoot(), defaultPath);
        }
        else {
            return defaultPath;
        }
    }
    /**
     Create a language book from a parent

     @param {Book} parent
     @param {string} language
     @return {Book}
     */
    static createFromParent(parent, language) {
        const ignore = parent.getIgnore();
        let config = parent.getConfig();
        // Set language in configuration
        config = config.setValue("language", language);
        return new Book({
            // Inherits config. logegr and list of ignored files
            logger: parent.getLogger(),
            config: config,
            ignore: ignore,
            language: language,
            fs: fs_1.default.reduceScope(parent.getContentFS(), language)
        });
    }
}
exports.default = Book;