import SKLocalUtil from "../util/SKLocalUtil";
import SKLogger from "../util/SKLogger";

export default class AudioManager {

    static shared: AudioManager = new AudioManager();
    static prefix: string = "";

    current: number;
    private musicVolume: number;
    private effectVolume: number;
    private voiceVolume: number;
    private audioCache: any;
    private music: string;

    constructor() {
        this.current = 0;
        this.musicVolume = SKLocalUtil.floatForKey("music_volume", 1);
        this.effectVolume = SKLocalUtil.floatForKey("effect_volume", 1);
        this.voiceVolume = SKLocalUtil.floatForKey("voice_volume", 1);
        this.audioCache = {};
    }

    static play(clip: cc.AudioClip, loop: boolean): number {
        return this.shared.play(clip, loop);
    }

    static stopPlay(audioID: number) {
        cc.audioEngine.stop(audioID);
    }

    static playMusic(url: string) {
        this.shared.playMusic(url);
    }

    static playAudio(url: string) {
        this.shared.playAudio(url);
    }

    static playLocalAudio(url: string, idBlock: (id: number) => void, endBlock: () => void): boolean {
        return this.shared.playLocalAudio(url, idBlock, endBlock);
    }

    static setMusicVolume(volume: number) {
        this.shared.setMusicVolume(volume);
    }

    static setEffectVolume(volume: number) {
        this.shared.setEffectVolume(volume);
    }

    static setVoiceVolume(volume: number) {
        this.shared.setVoiceVolume(volume);
    }

    static getMusicVolume(): number {
        return this.shared.getMusicVolume();
    }

    static getEffectVolume(): number {
        return this.shared.getEffectVolume();
    }

    static getVoiceVolume(): number {
        return this.shared.getVoiceVolume();
    }

    play(clip: cc.AudioClip, loop: boolean): number {
        if (loop) {
            cc.audioEngine.stop(this.current);
            this.current = cc.audioEngine.play(clip, loop, this.musicVolume);
            return this.current;
        } else {
            let current = cc.audioEngine.play(clip, loop, this.effectVolume);
            return current;
        }
    }

    playMusic(url: string) {
// 僅H5與安卓可以播放背景音樂
        // if (!cc.sys.isBrowser && cc.sys.os != cc.sys.OS_ANDROID) {
        //     return;
        // }
        if (this.music == url) {
            return;
        }
        let audio = this.audioCache[url];
        if (audio) {
            this.music = url;
SKLogger.debug(`播放音樂:${url}`);
            this.play(audio, true);
        } else {
            let self = this;
            cc.loader.loadRes(`${AudioManager.prefix}${url}`, cc.AudioClip, (error, resource) => {
                if (error) {
SKLogger.warn(`找不到音樂資源:${url},錯誤:${error}`);
                    return;
                }
                self.music = url;
                self.audioCache[url] = resource;
    SKLogger.debug(`播放音樂:${url}`);
                self.play(resource, true);
            });
        }
    }

    playAudio(url: string): number {
// 僅H5與安卓可以播放音效
        // if (!cc.sys.isBrowser && cc.sys.os != cc.sys.OS_ANDROID) {
        //     return;
        // }
        let audio = this.audioCache[url];
        if (audio) {
            return this.play(audio, false);
        } else {
            let self = this;
            cc.loader.loadRes(`${AudioManager.prefix}${url}`, cc.AudioClip, (error, resource) => {
                if (error) {
cc.warn(`找不到音效:${url},錯誤:${error}`);
                    return;
                }
                self.music = url;
                self.audioCache[url] = resource;
                self.play(resource, false);
            });
        }
    }

    playLocalAudio(url: string, idBlock: (id: number) => void, endBlock: () => void): boolean {
        if (!CC_JSB) {
            return false;
        }
        let self = this;
        // cc.audioEngine.uncache(url);
        cc.loader.loadRes(url, cc.AudioClip, (error, resource) => {
            if (error) {
cc.warn(`找不到本地音效:${url},錯誤:${error}`);
                idBlock(-1);
                return;
            }
            let audioID = self.play(resource, false);
            if (audioID < 1) {
                idBlock(-1);
            } else {
                idBlock(audioID);
            }
            jsb.AudioEngine.setFinishCallback(audioID, (id: number, filepath: string) => {
                if (endBlock) {
                    endBlock();
                }
            });
        });
        return true;
    }

    setMusicVolume(volume: number) {
        this.musicVolume = volume;
        cc.audioEngine.setVolume(this.current, this.musicVolume);
        SKLocalUtil.setFloat(this.musicVolume, "music_volume");
    }

    setEffectVolume(volume: number) {
        this.effectVolume = Math.floor(volume * 100) / 100;
        SKLocalUtil.setFloat(this.effectVolume, "effect_volume");
    }

    setVoiceVolume(volume: number) {
        this.voiceVolume = Math.floor(volume * 100) / 100;
        SKLocalUtil.setFloat(this.voiceVolume, "voice_volume");
    }

    getMusicVolume(): number {
        return this.musicVolume;
    }

    getEffectVolume(): number {
        return this.effectVolume;
    }

    getVoiceVolume(): number {
        return this.voiceVolume;
    }
}