import { AssetManager, AudioClip, Button, Game, _decorator, game, isValid, sys } from 'cc';
import { IEffectName, IMusicName } from '../../../../../assets/app-builtin/app-admin/executor';
import Core from '../../Core';
import BaseManager from '../../base/BaseManager';
import AudioEngine from './AudioEngine';
const { ccclass } = _decorator;

interface playMusic<T> { name: T, volume?: number, force?: boolean, onPlay?: Function, onError?: Function }
interface playEffect<T> { name: T, volume?: number, loop?: boolean, interval?: number, onPlay?: (audioID: number) => any, onError?: Function, onEnded?: Function }
interface playMusicAsync<T> { name: T, volume?: number, force?: boolean }
interface playEffectAsync<T> { name: T, volume?: number, loop?: boolean, interval?: number, onEnded?: Function }

interface playMusicWidthBundle { name: string, bundle: string, volume?: number, force?: boolean, onPlay?: Function, onError?: Function }
interface playEffectWidthBundle { name: string, bundle: string, volume?: number, loop?: boolean, interval?: number, onPlay?: (audioID: number) => any, onError?: Function, onEnded?: Function }
interface playMusicWidthBundleAsync { name: string, bundle: string, volume?: number, force?: boolean }
interface playEffectWidthBundleAsync { name: string, bundle: string, volume?: number, loop?: boolean, interval?: number, onEnded?: Function }

const storage = {
    set(key: string, value: any) {
        sys.localStorage.setItem(key, JSON.stringify(value));
    },
    get(key: string) {
        const data = sys.localStorage.getItem(key);
        if (data && typeof data === 'string') {
            return JSON.parse(data);
        }
        return undefined;
    }
};

/**
 * 音乐名字枚举
 */
const MusicName: { [key in IMusicName]: key } = new Proxy({} as any, {
    get: function (target, key) {
        if (target[key]) return target[key];
        target[key] = key;
        return key;
    }
});

/**
 * 音效名字枚举
 */
const EffectName: { [key in IEffectName]: key } = new Proxy({} as any, {
    get: function (target, key) {
        if (target[key]) return target[key];
        target[key] = key;
        return key;
    }
});

const BundleName = 'app-sound';
@ccclass('SoundManager')
export default class SoundManager<E extends string, M extends string> extends BaseManager {
    /**静态设置 */
    static setting: {
        /**预加载 */
        preload?: (IMusicName | IEffectName)[],

        /**默认播放的音乐名 */
        defaultMusicName?: IMusicName | '',
        /**默认音乐的音量 */
        defaultMusicVolume?: number,

        /**默认按钮的音效名 */
        defaultEffectName?: IEffectName | '',
        /**默认按钮音效的音量 */
        defaultEffectVolume?: number
    } = {};

    /**音乐名字枚举 */
    static MusicName = MusicName;
    /**音效名字枚举 */
    static EffectName = EffectName;

    private musicMuteCacheKey = 'SoundManager:MusicMute';
    private effectMuteCacheKey = 'SoundManager:EffectMute';
    private musicVolumeScaleCacheKey = 'SoundManager:MusicVolumeScale';
    private effectVolumeScaleCacheKey = 'SoundManager:EffectVolumeScale';

    private defaultMusicName = '';
    private defaultMusicVolume = 0.2;
    private defaultEffectName = '';
    private defaultEffectVolume = 1;

    private audioCache = {};
    private effectInterval: { [key in string]: number } = {};
    private playingMusic = { uuid: '', id: -1, name: '', volume: 1, playing: false, paused: false };

    protected init(finish: Function) {
        const setting = SoundManager.setting;

        // 默认音乐
        if (setting.defaultMusicName) this.defaultMusicName = setting.defaultMusicName;
        if (typeof setting.defaultMusicVolume === 'number') this.defaultMusicVolume = setting.defaultMusicVolume;

        // 默认按钮音效
        if (setting.defaultEffectName) this.defaultEffectName = setting.defaultEffectName;
        if (typeof setting.defaultEffectVolume === 'number') this.defaultEffectVolume = setting.defaultEffectVolume;

        if (this.musicMuteCacheKey) {
            const musicMute = storage.get(this.musicMuteCacheKey) === true;
            AudioEngine.inst.setMusicMute(musicMute);
        } else {
            this.warn('musicMuteCacheKey不能为空');
        }
        if (this.effectMuteCacheKey) {
            const effectMute = storage.get(this.effectMuteCacheKey) === true;
            AudioEngine.inst.setGlobalEffectsMute(effectMute);
        } else {
            this.warn('effectMuteCacheKey不能为空');
        }
        if (this.musicVolumeScaleCacheKey) {
            const musicVolumeScale = storage.get(this.musicVolumeScaleCacheKey);
            if (typeof musicVolumeScale === 'number') AudioEngine.inst.setMusicVolumeScale(musicVolumeScale);
        } else {
            this.warn('musicVolumeScaleCacheKey不能为空');
        }
        if (this.effectVolumeScaleCacheKey) {
            const effectVolumeScale = storage.get(this.effectVolumeScaleCacheKey);
            if (typeof effectVolumeScale === 'number') AudioEngine.inst.setGlobalEffectsVolumeScale(effectVolumeScale);
        } else {
            this.warn('effectVolumeScaleCacheKey不能为空');
        }

        super.init(finish);

        // 预加载
        setting.preload?.forEach((path: string) => {
            Core.inst.manager.loader.preload({
                bundle: BundleName,
                type: AudioClip,
                path: path
            });
        });
    }

    protected onLoad() {
        game.on(Game.EVENT_HIDE, function () {
            AudioEngine.inst.pauseAll();
        });
        game.on(Game.EVENT_SHOW, function () {
            AudioEngine.inst.resumeAll();
        });
    }

    /**
     * 预加载声音资源
     * @param name sound路径
     * @param bundle Bundle名，默认为app-sound
     */
    public preload(name: string, bundle: string, complete?: (item: AssetManager.RequestItem[] | null) => any): void;
    public preload(name: (E | M), complete?: (item: AssetManager.RequestItem[] | null) => any): void;
    public preload(name: string, ...args: any[]) {
        const bundleName = (args.length >= 1
            && (typeof args[0] === 'string')
            ? (args[0] || BundleName)
            : BundleName
        ) as string;
        const complete = (args.length >= 1
            && (args[args.length - 1] instanceof Function)
            ? args[args.length - 1]
            : null
        ) as (item: AssetManager.RequestItem[] | null) => any;

        if (!name) {
            this.error('preload', 'fail');
            complete && setTimeout(() => {
                if (!isValid(this)) return;
                complete(null);
            });
            return;
        }

        if (name.indexOf('effect') !== 0 && name.indexOf('music') !== 0) {
            this.error('preload', 'fail', name);
            complete && setTimeout(() => {
                if (!isValid(this)) return;
                complete(null);
            });
            return;
        }

        // 远程加载
        Core.inst.manager.loader.preload({
            bundle: bundleName,
            path: name,
            type: AudioClip,
            onComplete: complete
        });
    }

    /**
     * 加载声音资源
     * @param name sound路径
     * @param bundle Bundle名，默认为app-sound
     * @param progress 加载进度回调
     * @param complete 加载完成回调
     */
    public load(name: string, bundle: string): void;
    public load(name: string, bundle: string, complete: (result: AudioClip | null) => any): void;
    public load(name: string, bundle: string, progress: (finish: number, total: number, item: AssetManager.RequestItem) => void, complete: (result: AudioClip | null) => any): void;
    public load(name: (E | M)): void;
    public load(name: (E | M), complete: (result: AudioClip | null) => any): void;
    public load(name: (E | M), progress: (finish: number, total: number, item: AssetManager.RequestItem) => void, complete: (result: AudioClip | null) => any): void;
    public load(name: string, ...args: any[]): void {
        const bundleName = (args.length >= 1
            && (typeof args[0] === 'string')
            ? (args[0] || BundleName)
            : BundleName
        ) as string;
        const progress = (args.length >= 2
            && (args[args.length - 1] instanceof Function)
            && (args[args.length - 2] instanceof Function)
            ? args[args.length - 2]
            : null
        ) as (finish: number, total: number, item: AssetManager.RequestItem) => void;
        const complete = (args.length >= 1
            && (args[args.length - 1] instanceof Function)
            ? args[args.length - 1]
            : null
        ) as (result: AudioClip | null) => any;

        if (!name) {
            this.error('load', 'fail');
            complete && setTimeout(() => {
                if (!isValid(this)) return;
                complete(null);
            });
            return;
        }

        const soundName = `${bundleName}://${name}`;

        // 判断有无缓存
        const audio = this.audioCache[soundName];
        if (audio) {
            complete && setTimeout(() => {
                if (!isValid(this)) return;
                complete(audio);
            });
            return;
        }

        // 远程加载
        Core.inst.manager.loader.load({
            path: name,
            bundle: bundleName,
            type: AudioClip,
            onProgress: progress,
            onComplete: (audioClip) => {
                if (!isValid(this)) return;
                if (audioClip) {
                    this.audioCache[soundName] = audioClip;
                    complete && complete(audioClip);
                } else {
                    complete && complete(null);
                }
            }
        });
    }

    /**
     * 释放声音资源
     * @param name 声音路径
     * @param bundle Bundle名，默认为app-sound
     */
    public release(name: string, bundle: string): void;
    public release(name: E | M): void;
    public release(name: string, bundle?: string) {
        const bundleName = bundle || BundleName;
        const soundName = `${bundleName}://${name}`;

        delete this.audioCache[soundName];
        Core.inst.manager.loader.release({ bundle: bundleName, path: name, type: AudioClip });
    }

    /**
     * 播放默认音乐
     */
    public playDefaultMusic(onPlay?: Function) {
        if (this.defaultMusicName) {
            this.playMusic({ name: <M>this.defaultMusicName, volume: this.defaultMusicVolume, onPlay });
        } else {
            this.warn('defaultMusicName 不存在');
        }
    }

    /**
     * 播放默认音效
     */
    public playDefaultEffect(onPlay?: (audioID: number) => void) {
        if (this.defaultEffectName) {
            this.playEffect({ name: <E>this.defaultEffectName, volume: this.defaultEffectVolume, onPlay });
        } else {
            this.warn('defaultEffectName 不存在');
        }
    }

    /**
     * 设置按钮点击播放的音效，优先级高于默认音效
     * @param name 音效(如果为空，则使用默认音效)
     * @param opts.volume 音量
     * @param opts.interval 多少秒内不会重复播放
     */
    public setButtonEffect(target: Button, name?: E, opts?: {
        volume: number,
        interval: number
    }) {
        if (name) {
            const { volume = 1, interval = 0 } = opts || {};
            //@ts-ignore
            target.node['useDefaultEffect'] = false;
            target.node.targetOff(this);
            target.node.on(Button.EventType.CLICK, function (this: SoundManager<E, M>) {
                this.playEffect({ name, volume, interval });
            }, this);
        } else {
            //@ts-ignore
            target.node['useDefaultEffect'] = true;
            target.node.targetOff(this);
        }
    }

    /**
     * 播放音效
     * @param name 音效
     * @param bundle Bundle名，默认为app-sound
     * @param loop 循环播放
     * @param volume 音量
     * @param interval 多少秒内不会重复播放
     */
    public playEffect({ name, volume, loop, interval, onEnded, onPlay, onError }: playEffect<E>): void;
    public playEffect({ name, bundle, volume, loop, interval, onEnded, onPlay, onError }: playEffectWidthBundle): void;
    public playEffect({ name, bundle, volume = 1, loop = false, interval = 0, onEnded, onPlay, onError }) {
        if (!name) {
            onError && onError();
            return;
        }

        const bundleName = bundle || BundleName;
        const soundName = `${bundleName}://${name}`;

        // 静音不允许播放
        if (this.isEffectMute) {
            onError && onError();
            return;
        }
        // 正在播放中，不允许重复播放
        if (this.effectInterval[soundName] && Date.now() < this.effectInterval[soundName]) {
            onError && onError();
            return;
        }

        // 加载音乐
        this.load(name, bundleName, (audioClip) => {
            if (!isValid(this)) {
                onError && onError();
                return;
            }
            // 静音不允许播放
            if (this.isEffectMute) {
                onError && onError();
                return;
            }
            // 正在播放中，不允许重复播放
            if (this.effectInterval[soundName] && Date.now() < this.effectInterval[soundName]) {
                onError && onError();
                return;
            }
            if (!audioClip) {
                this.error(`playEffect ${name} 不存在或加载失败`);
                onError && onError();
                return;
            }

            if (interval > 0) {
                this.effectInterval[soundName] = Date.now() + interval * 1000;
            }

            AudioEngine.inst.playEffect(audioClip, volume, loop, onPlay, onEnded);
        });
    }

    /**
     * 播放音效
     * @param name 音效
     * @param bundle Bundle名，默认为app-sound
     * @param loop 循环播放
     * @param volume 音量
     * @param interval 多少秒内不会重复播放
     * @returns 如果Promise返回值是null(非真)，则播放失败
     */
    public async playEffectAsync(params: playEffectAsync<E>): Promise<number>;
    public async playEffectAsync(params: playEffectWidthBundleAsync): Promise<number>;
    public async playEffectAsync(params: any): Promise<number> {
        return new Promise((resolve) => {
            this.playEffect({
                ...params,
                onPlay: (audioID) => {
                    resolve(audioID);
                },
                onError: () => {
                    resolve(null);
                }
            });
        });
    }

    /**
     * 暂停音效
     * @param id 
     * @returns 
     */
    public pauseEffect(id: number) {
        return AudioEngine.inst.pauseEffect(id);
    }

    /**
     * 暂停所有音效
     * @returns 
     */
    public pauseAllEffects() {
        return AudioEngine.inst.pauseAllEffects();
    }

    /**
     * 恢复音效
     * @param id 
     * @returns 
     */
    public resumeEffect(id: number) {
        return AudioEngine.inst.resumeEffect(id);
    }

    /**
     * 恢复所有音效
     * @returns 
     */
    public resumeAllEffects() {
        return AudioEngine.inst.resumeAllEffects();
    }

    /**
     * 停止音效
     * @param id 
     * @returns 
     */
    public stopEffect(id: number) {
        return AudioEngine.inst.stopEffect(id);
    }

    /**
     * 停止所有音效
     * @returns 
     */
    public stopAllEffects() {
        return AudioEngine.inst.stopAllEffects();
    }

    /**
     * 播放音乐
     * @param volume 音量
     * @param bundle Bundle名，默认为app-sound
     * @param force 是否强制重新播放
     */
    public playMusic(params: playMusic<M>): void;
    public playMusic(params: playMusicWidthBundle): void;
    public playMusic({ name, bundle, volume = 1, force = false, onPlay, onError }): void {
        if (!name) {
            onError && onError();
            return;
        }

        const bundleName = bundle || BundleName;
        const soundName = `${bundleName}://${name}`;

        // 该音乐正在播放中
        if (!force && this.playingMusic.id !== -1 && this.playingMusic.name === soundName) {
            AudioEngine.inst.setMusicVolume(volume);
            onPlay && onPlay();
            return;
        }

        // 先停止当前音乐
        this.stopMusic();

        // 播放操作uuid
        const uuid = this.createUUID();
        this.playingMusic.uuid = uuid;
        // 记录要播放音乐的名字
        this.playingMusic.name = soundName;
        // 记录要播放音乐的音量
        this.playingMusic.volume = volume;
        // 记录音乐状态
        this.playingMusic.playing = true;
        this.playingMusic.paused = false;

        // 静音
        if (this.isMusicMute) {
            onPlay && onPlay();
            return;
        }

        // 加载音乐
        this.load(name, bundleName, (audioClip) => {
            if (!isValid(this)) {
                onError && onError();
                return;
            }
            // 不合法
            if (this.playingMusic.id !== -1) {
                onError && onError();
                return;
            }
            if (this.playingMusic.name !== soundName) {
                onError && onError();
                return;
            }
            if (this.playingMusic.uuid !== this.playingMusic.uuid) {
                onError && onError();
                return;
            }
            // 不存在
            if (!audioClip) {
                this.error(`playMusic ${name} 不存在或加载失败`);
                onError && onError();
                return;
            }
            // 静音
            if (this.isMusicMute) {
                onPlay && onPlay();
                return;
            }

            this.playingMusic.id = AudioEngine.inst.playMusic(audioClip, volume, onPlay);
        });
    }

    /**
     * 播放音乐
     * @param volume 音量
     * @param bundle Bundle名，默认为app-sound
     * @param force 是否强制重新播放
     * @returns 如果Promise返回值是false，则播放失败
     */
    public playMusicAsync(params: playMusicAsync<M>): Promise<boolean>;
    public playMusicAsync(params: playMusicWidthBundleAsync): Promise<boolean>;
    public playMusicAsync(params: any): Promise<boolean> {
        return new Promise((resolve) => {
            this.playMusic({
                ...params,
                onPlay: () => {
                    resolve(true);
                },
                onError: () => {
                    resolve(false);
                }
            });
        });
    }

    /**
     * 重新播放音乐
     */
    public replayMusic(onPlay?: Function) {
        if (!this.playingMusic.playing) return;
        if (!this.playingMusic.name) return;
        if (this.playingMusic.name.indexOf('://') > 0) {
            const [bundle, name] = this.playingMusic.name.split('://');
            this.playMusic({
                name,
                bundle,
                volume: this.playingMusic.volume,
                force: true,
                onPlay
            });
        } else {
            this.playMusic({
                name: this.playingMusic.name as any,
                volume: this.playingMusic.volume,
                force: true,
                onPlay
            });
        }
    }

    /**
     * 暂停音乐
     */
    public pauseMusic() {
        if (!this.playingMusic.playing) return false;
        this.playingMusic.paused = true;
        return AudioEngine.inst.pauseMusic();
    }

    /**
     * 恢复音乐
     */
    public resumeMusic() {
        if (!this.playingMusic.playing) return false;
        this.playingMusic.paused = false;
        return AudioEngine.inst.resumeMusic();
    }

    /**
     * 停止音乐
     */
    public stopMusic() {
        this.playingMusic.playing = false;
        this.playingMusic.paused = false;
        this.playingMusic.volume = 1;
        this.playingMusic.name = '';
        this.playingMusic.uuid = '';
        this.playingMusic.id = -1;
        return AudioEngine.inst.stopMusic();
    }

    /**
     * 设置音乐静音
     * @param mute 是否静音
     * @param isCache 静音状态是否写入缓存(通过localstorage)
     */
    public setMusicMute(mute: boolean, isCache = false) {
        isCache && storage.set(this.musicMuteCacheKey, mute);
        AudioEngine.inst.setMusicMute(mute);
        if (!mute && this.playingMusic.name) {
            if (this.playingMusic.name.indexOf('://') > 0) {
                const [bundle, name] = this.playingMusic.name.split('://');
                this.playMusic({
                    name,
                    bundle,
                    volume: this.playingMusic.volume,

                });
            } else {
                this.playMusic({
                    name: this.playingMusic.name as any,
                    volume: this.playingMusic.volume
                });
            }
        }
    }

    /**
     * 音乐是否正在播放
     */
    get isMusicPlaying() {
        return this.playingMusic.playing;
    }

    /**
     * 音乐是否暂停
     */
    get isMusicPaused() {
        return this.playingMusic.paused;
    }

    /**
     * 音乐是否静音
     */
    public get isMusicMute() {
        return AudioEngine.inst.getMusicMute();
    }

    /**
     * 设置音效静音
     * @param mute 是否静音
     * @param isCache 静音状态是否写入缓存(通过localstorage)
     */
    public setEffectMute(mute: boolean, isCache = false) {
        AudioEngine.inst.setGlobalEffectsMute(mute);
        isCache && storage.set(this.effectMuteCacheKey, mute);
    }

    /**
     * 音效是否静音
     */
    public get isEffectMute() {
        return AudioEngine.inst.getGlobalEffectsMute();
    }

    /**
     * 设置音乐音量倍率
     * @param scale 
     * @param isCache 音量倍率是否写入缓存(通过localstorage)
     */
    public setMusicVolumeScale(scale: number, isCache = false) {
        AudioEngine.inst.setMusicVolumeScale(scale);
        isCache && storage.set(this.musicVolumeScaleCacheKey, scale);
    }

    /**
     * 音乐音量倍率
     */
    public get musicVolumeScale() {
        return AudioEngine.inst.getMusicVolumeScale();
    }

    /**
     * 设置音效音量倍率
     * @param scale 
     * @param isCache 音量倍率是否写入缓存(通过localstorage)
     */
    public setEffectVolumeScale(scale: number, isCache = false) {
        AudioEngine.inst.setGlobalEffectsVolumeScale(scale);
        isCache && storage.set(this.effectVolumeScaleCacheKey, scale);
    }

    /**
     * 音效音量倍率
     */
    public get effectVolumeScale() {
        return AudioEngine.inst.getGlobalEffectsVolumeScale();
    }
}