'use strict';
const { DeveloperError } = require('cesium');
const fsExtra = require('fs-extra');
const path = require('path');
const Promise = require('bluebird');
const createGltf = require('../../lib/createGltf');
const obj2gltf = require('../../lib/obj2gltf');

const texturedObjPath = 'specs/data/box-textured/box-textured.obj';
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
const missingMtllibObjPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj';

const outputDirectory = 'output';

const textureUrl = 'specs/data/box-textured/cesium.png';

describe('obj2gltf', () => {
    beforeEach(() => {
        spyOn(fsExtra, 'outputFile').and.returnValue(Promise.resolve());
    });

    it('converts obj to gltf', async () => {
        const gltf = await obj2gltf(texturedObjPath);
        expect(gltf).toBeDefined();
        expect(gltf.images.length).toBe(1);
    });

    it('converts obj to glb', async () => {
        const options = {
            binary : true
        };
        const glb = await obj2gltf(texturedObjPath, options);
        const magic = glb.toString('utf8', 0, 4);
        expect(magic).toBe('glTF');
    });

    it('convert obj to gltf with separate resources', async () => {
        const options = {
            separate : true,
            separateTextures : true,
            outputDirectory : outputDirectory
        };
        await obj2gltf(texturedObjPath, options);
        expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
    });

    it('convert obj to gltf with separate resources when buffer exceeds Node limit', async () => {
        spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
        const options = {
            separate : true,
            separateTextures : true,
            outputDirectory : outputDirectory
        };
        await obj2gltf(texturedObjPath, options);
        expect(fsExtra.outputFile.calls.count()).toBe(5); // Saves out .png and four .bin for positions, normals, uvs, and indices
    });

    it('converts obj to glb with separate resources', async () => {
        const options = {
            separate : true,
            separateTextures : true,
            outputDirectory : outputDirectory,
            binary : true
        };
        await obj2gltf(texturedObjPath, options);
        expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
    });

    it('converts obj with multiple textures', async () => {
        const options = {
            separateTextures : true,
            outputDirectory : outputDirectory
        };
        await obj2gltf(complexObjPath, options);
        expect(fsExtra.outputFile.calls.count()).toBe(5); // baseColor, metallicRoughness, occlusion, emission, normal
    });

    it('sets overriding textures (1)', async () => {
        const options = {
            overridingTextures : {
                metallicRoughnessOcclusionTexture : textureUrl,
                normalTexture : textureUrl,
                baseColorTexture : textureUrl,
                emissiveTexture : textureUrl,
                alphaTexture : textureUrl
            },
            separateTextures : true,
            outputDirectory : outputDirectory
        };
        await obj2gltf(complexObjPath, options);
        const args = fsExtra.outputFile.calls.allArgs();
        const length = args.length;
        for (let i = 0; i < length; ++i) {
            expect(path.basename(args[i][0])).toBe(path.basename(textureUrl));
        }
    });

    it('sets overriding textures (2)', async () => {
        const options = {
            overridingTextures : {
                specularGlossinessTexture : textureUrl,
                occlusionTexture : textureUrl,
                normalTexture : textureUrl,
                baseColorTexture : textureUrl,
                emissiveTexture : textureUrl,
                alphaTexture : textureUrl
            },
            separateTextures : true,
            outputDirectory : outputDirectory
        };
        await obj2gltf(complexObjPath, options);
        const args = fsExtra.outputFile.calls.allArgs();
        const length = args.length;
        for (let i = 0; i < length; ++i) {
            expect(path.basename(args[i][0])).toBe(path.basename(textureUrl));
        }
    });

    it('uses a custom logger', async () => {
        let lastMessage;
        const options = {
            logger : (message) => {
                lastMessage = message;
            }
        };
        await obj2gltf(missingMtllibObjPath, options);
        expect(lastMessage.indexOf('Could not read material file') >= 0).toBe(true);
    });

    it('uses a custom writer', async () => {
        const filePaths = [];
        const fileContents = [];
        const options = {
            separate : true,
            writer : (relativePath, contents) => {
                filePaths.push(relativePath);
                fileContents.push(contents);
            }
        };
        await obj2gltf(texturedObjPath, options);
        expect(filePaths).toEqual(['cesium.png', 'box-textured.bin']);
        expect(fileContents[0]).toBeDefined();
        expect(fileContents[1]).toBeDefined();
    });

    it('throws if objPath is undefined', () => {
        let thrownError;
        try {
            obj2gltf(undefined);
        } catch (e) {
            thrownError = e;
        }
        expect(thrownError).toEqual(new DeveloperError('objPath is required'));
    });

    it('throws if both options.writer and options.outputDirectory are undefined when writing separate resources', () => {
        const options = {
            separateTextures : true
        };

        let thrownError;
        try {
            obj2gltf(texturedObjPath, options);
        } catch (e) {
            thrownError = e;
        }
        expect(thrownError).toEqual(new DeveloperError('Either options.writer or options.outputDirectory must be defined when writing separate resources.'));
    });

    it('throws if more than one material type is set', () => {
        const options = {
            metallicRoughness : true,
            specularGlossiness : true
        };

        let thrownError;
        try {
            obj2gltf(texturedObjPath, options);
        } catch (e) {
            thrownError = e;
        }
        expect(thrownError).toEqual(new DeveloperError('Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].'));
    });

    it('throws if metallicRoughnessOcclusionTexture and specularGlossinessTexture are both defined', () => {
        const options = {
            overridingTextures : {
                metallicRoughnessOcclusionTexture : textureUrl,
                specularGlossinessTexture : textureUrl
            }
        };

        let thrownError;
        try {
            obj2gltf(texturedObjPath, options);
        } catch (e) {
            thrownError = e;
        }
        expect(thrownError).toEqual(new DeveloperError('metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.'));
    });
});