/*!
 * @license
 * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Injectable } from '@angular/core';
import { AppExtensionService, ViewerExtensionRef } from '@alfresco/adf-extensions';

@Injectable({
    providedIn: 'root'
})
export class ViewUtilService {
    // Extensions that are supported by the Viewer without conversion
    private extensions = {
        image: ['png', 'jpg', 'jpeg', 'gif', 'bpm', 'svg'],
        media: ['wav', 'mp4', 'mp3', 'webm', 'ogg'],
        text: ['txt', 'xml', 'html', 'json', 'ts', 'css', 'md'],
        pdf: ['pdf']
    };

    // Mime types that are supported by the Viewer without conversion
    private mimeTypes = {
        text: ['text/plain', 'text/csv', 'text/xml', 'text/html', 'application/x-javascript'],
        pdf: ['application/pdf'],
        image: ['image/png', 'image/jpeg', 'image/gif', 'image/bmp', 'image/svg+xml'],
        media: ['video/mp4', 'video/webm', 'video/ogg', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/wav']
    };

    /**
     * Returns a list of the active Viewer content extensions.
     *
     * @returns list of extension references
     */
    get viewerExtensions(): ViewerExtensionRef[] {
        return this.extensionService.getViewerExtensions();
    }

    /**
     * Provides a list of file extensions supported by external plugins.
     *
     * @returns list of extensions
     */
    get externalExtensions(): string[] {
        return this.viewerExtensions.map((ext) => ext.fileExtension);
    }

    constructor(private extensionService: AppExtensionService) {}

    /**
     * get File name from url
     *
     * @param  url - url file
     * @returns file name portion of the url
     */
    getFilenameFromUrl(url: string): string {
        const anchor = url.indexOf('#');
        const query = url.indexOf('?');
        const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
        return url.substring(url.lastIndexOf('/', end) + 1, end);
    }

    /**
     * Get file extension from the string.
     * Supports the URL formats like:
     * http://localhost/test.jpg?cache=1000
     * http://localhost/test.jpg#cache=1000
     *
     * @param fileName - file name
     * @returns file extension
     */
    getFileExtension(fileName: string): string {
        if (fileName) {
            const match = fileName.match(/\.([^./?#]+)($|\?|#)/);
            return match ? match[1] : null;
        }
        return null;
    }

    getViewerType(extension: string, mimeType: string, extensionsSupportedByTemplates?: string[]): string {
        let viewerType = this.getViewerTypeByExtension(extension, extensionsSupportedByTemplates);

        if (viewerType === 'unknown') {
            viewerType = this.getViewerTypeByMimeType(mimeType);
        }

        return viewerType;
    }

    getViewerTypeByMimeType(mimeType: string) {
        if (mimeType) {
            mimeType = mimeType.toLowerCase();

            const editorTypes = Object.keys(this.mimeTypes);
            for (const type of editorTypes) {
                if (this.mimeTypes[type].indexOf(mimeType) >= 0) {
                    return type;
                }
            }
        }
        return 'unknown';
    }

    private getViewerTypeByExtension(extension: string, extensionsSupportedByTemplates?: string[]): string {
        if (extension) {
            extension = extension.toLowerCase();
        }

        if (this.isExternalViewer()) {
            return 'external';
        }

        if (this.isCustomViewerExtension(extension, extensionsSupportedByTemplates)) {
            return 'custom';
        }

        if (this.extensions.image.indexOf(extension) >= 0) {
            return 'image';
        }

        if (this.extensions.media.indexOf(extension) >= 0) {
            return 'media';
        }

        if (this.extensions.text.indexOf(extension) >= 0) {
            return 'text';
        }

        if (this.extensions.pdf.indexOf(extension) >= 0) {
            return 'pdf';
        }

        return 'unknown';
    }

    private isExternalViewer(): boolean {
        return !!this.viewerExtensions.find((ext) => ext.fileExtension === '*');
    }

    isCustomViewerExtension(extension: string, extensionsSupportedByTemplates?: string[]): boolean {
        const extensions = this.externalExtensions || [];
        if (extensionsSupportedByTemplates) {
            extensions.push(...extensionsSupportedByTemplates);
        }

        if (extension && extensions.length > 0) {
            extension = extension.toLowerCase();
            return extensions.flat().indexOf(extension) >= 0;
        }

        return false;
    }
}