package samples;

import com.ding.rtc.DingRtcEngine;
import com.ding.rtc.DingRtcEngineListener;
import org.json.JSONObject;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Random;

public class LinuxServerPullDemo {

    static class RtcContext {
        DingRtcEngine engine = null;
        DingRtcEngineListener listener = null;

        volatile boolean joinFinished = false;
        int joinResult = -1;

        // for audio
        volatile boolean isPullAudioStarted = false;
        AudioObserver audioObserver = null;

        // for video
        volatile boolean isPullVideoStarted = false;
        VideoObserver videoObserver = null;

        void reset() {
            log("context reset");
            if (engine != null) {
                engine.destroy();
            }
            engine = null;
            listener = null;
            audioObserver = null;
            videoObserver = null;
        }
    }

    static class RtcListener extends DingRtcEngineListener {

        private final RtcContext mRtcContext;

        RtcListener(RtcContext context) {
            mRtcContext = context;
        }

        @Override
        public void onJoinChannelResult(int result, String channel, String userId, int elapsed) {
            log("[Callback] onJoinChannelResult : " + result + ", channel : " + channel + ", uid : " + userId + ", elapsed: " + elapsed);
            if (mRtcContext != null) {
                mRtcContext.joinFinished = true;
                mRtcContext.joinResult = result;
            }
        }

        @Override
        public void onLeaveChannelResult(int result) {
            log("[Callback] onLeaveChannelResult : " + result);
        }


    }

    static class AudioObserver extends DingRtcEngine.DingRtcAudioFrameObserver {
        private final RtcContext mRtcContext;
        private FileOutputStream mFile;

        public AudioObserver(RtcContext context) {
            mRtcContext = context;
        }

        @Override
        public boolean onCapturedAudioFrame(DingRtcEngine.DingRtcAudioFrame frame) {
            return false;
        }

        @Override
        public boolean onProcessCapturedAudioFrame(DingRtcEngine.DingRtcAudioFrame frame) {
            return false;
        }

        @Override
        public boolean onPublishAudioFrame(DingRtcEngine.DingRtcAudioFrame frame) {
            return false;
        }

        @Override
        public boolean onPlaybackAudioFrame(DingRtcEngine.DingRtcAudioFrame frame) {
            // 拉流播放数据
            // TODO do save or other logic, ex: asr
            return false;
        }
    }

    static class VideoObserver extends DingRtcEngine.DingRtcVideoFrameObserver {

        private final RtcContext mRtcContext;
        private FileOutputStream mFile;

        public VideoObserver(RtcContext context) {
            mRtcContext = context;
        }

        @Override
        public DingRtcEngine.DingRtcVideoFormat getVideoFormatPreference() {
            // 期望数据格式，目前仅支持I420格式
            return DingRtcEngine.DingRtcVideoFormat.DingRtcVideoI420;
        }

        @Override
        public boolean onCaptureVideoFrame(DingRtcEngine.DingRtcVideoSample videoSample) {
            return false;
        }

        @Override
        public boolean onPreEncodeVideoFrame(DingRtcEngine.DingRtcVideoTrack track, DingRtcEngine.DingRtcVideoSample videoSample) {
            return false;
        }

        @Override
        public boolean onRemoteVideoFrame(String uid, DingRtcEngine.DingRtcVideoTrack track, DingRtcEngine.DingRtcVideoSample videoSample) {
            // 远端用户视频数据回调
            // TODO do save or other logic
            return false;
        }

    }

    private static void log(Object... args) {
        if (args != null && args.length > 0) {
            for (Object o : args) {
                if (o != null) {
                    System.out.print(o);
                }
            }
            System.out.println();
        }
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        log("[Demo] main start");
        LinuxServerPullDemo demo = new LinuxServerPullDemo();
        demo.run(args);
        log("[Demo] main finish");
    }

    public void run(String[] args) {
        log("************** [Demo] begin   **************  \n");
        log("[Demo] current dir : " + System.getProperty("user.dir"));
        RtcContext context = new RtcContext();

        // 1. 初始化SDK
        step_1_init_sdk(context);

        // 2. 入会
        step_2_join(context);

        // 为了演示方便，同步等待join成功，等onJoinChannelResult回调触发
        if (!wait_join_result(context)) {
            // join fail
            return;
        }

        // 3. 开始拉音视频流
        step_3_start_pull_audio_video_data(context);

        // 为了演示方便，同步等10s后，主动停止拉流
        sleep(10 * 1000);

        // 4. 停止拉音频、视频裸数据
        step_4_stop_pull_audio_video_data(context);

        // 5. 离会
        step_5_leave(context);

        // 6. 销毁
        step_6_destroy(context);

        context.reset();
        log("************** [Demo] end   **************  \n");
    }

    private boolean wait_join_result(RtcContext context) {
        while (!context.joinFinished) {
            sleep(500);
        }
        if (context.joinResult != 0) {
            // 入会失败，退出
            // 需要检查authinfo是否请求正确
            log("[Demo] join failed, return");
            context.reset();
            return false;
        }
        return true;
    }

    private void step_1_init_sdk(RtcContext context) {
        initRtcEngine(context);
        if (context.engine != null) {
            // 设置是否订阅音频流，默认会自动订阅，可以不调用
            // note:目前音频流仅支持合流订阅，单人订阅后续支持
            context.engine.subscribeAllRemoteAudioStreams(true);

            // 设置是否订阅视频流，默认会自动订阅，可以不调用
            // 也可以仅订阅单人 context.engine.subscribeRemoteVideoStream(userId, DingRtcEngine.DingRtcVideoTrack.DingRtcVideoTrackCamera, true);
            context.engine.subscribeAllRemoteVideoStreams(true);
        }
    }

    private void step_2_join(RtcContext context) {
        DingRtcEngine.DingRtcAuthInfo authInfo = getAuthInfoFromServer(context);
        if (context.engine != null) {
            context.engine.joinChannel(authInfo, "张三");
        }
    }

    private void step_3_start_pull_audio_video_data(RtcContext context) {
        startPullAudioData(context);
        startPullVideoData(context);
    }

    private void step_4_stop_pull_audio_video_data(RtcContext context) {
        stopPullAudioData(context);
        stopPullVideoData(context);
    }

    private void step_5_leave(RtcContext context) {
        if (context.engine != null) {
            context.engine.leaveChannel();
        }
    }

    private void step_6_destroy(RtcContext context) {
        if (context.engine != null) {
            context.engine.destroy();
            context.engine = null;
        }
    }

    /**
     * 停止音频拉流
     */
    private void stopPullAudioData(RtcContext context) {
        if (!context.isPullAudioStarted) {
            return;
        }
        if (context.engine != null) {
            // 1. 关闭音频数据订阅位置
            context.engine.enableAudioFrameObserver(false, DingRtcEngine.DintRtcAudioObservePosition.RtcEngineAudioPositionPlayback);

            // 2. 取消注册observer
            context.engine.registerAudioFrameObserver(null);

            // 3. 关闭音量提示和说话人提示功能，interval <= 0 代表关闭
            // 相关信息见回调： onAudioVolumeIndication
            context.engine.enableAudioVolumeIndication(0, 3, 1);
        }
        if (context.audioObserver != null) {
            context.audioObserver = null;
        }
        context.isPullAudioStarted = false;
    }

    /**
     * 开始音频拉流，获取播放PCM数据（支持配置采样率和通道数）
     * PCM数据见 AudioObserver::onPlaybackAudioFrame
     */
    private void startPullAudioData(RtcContext context) {
        if (context.isPullAudioStarted) {
            return;
        }
        if (context.audioObserver != null) {
            context.audioObserver = null;
        }
        if (context.engine != null) {
            // 1. 创建音频数据输出observer，并注册到engine中
            context.audioObserver = new AudioObserver(context);
            context.engine.registerAudioFrameObserver(context.audioObserver);

            // 2. 开启音频数据订阅位置，并设置期望输出的音频PCM数据采样率和通道数
            DingRtcEngine.DingRtcAudioFrameObserverConfig config = new DingRtcEngine.DingRtcAudioFrameObserverConfig();
            config.sampleRate = DingRtcEngine.DingRtcAudioSampleRate.DingRtcAudioSampleRate_16000;
            config.channels = DingRtcEngine.DingRtcAudioNumChannelType.DingRtcMonoAudio;
            context.engine.enableAudioFrameObserver(true, DingRtcEngine.DintRtcAudioObservePosition.RtcEngineAudioPositionPlayback, config);

            // 3. 开启音量提示和说话人提示功能，interval > 0 代表开启，<= 0 代表关闭
            // 相关信息见回调： onAudioVolumeIndication
            context.engine.enableAudioVolumeIndication(300, 3, 1);
        }
        context.isPullAudioStarted = true;
    }

    /**
     * 停止视频拉流
     */
    private void stopPullVideoData(RtcContext context) {
        if (!context.isPullVideoStarted) {
            return;
        }
        if (context.engine != null) {
            // 1. 关闭视频数据订阅位置
            context.engine.enableVideoFrameObserver(false, DingRtcEngine.DingRtcVideoObservePosition.DingRtcPositionPreRender);

            // 2. 移除视频数据回调observer
            context.engine.registerVideoFrameObserver(null);
        }
        if (context.videoObserver != null) {
            context.videoObserver = null;
        }
        context.isPullVideoStarted = false;
    }

    /**
     * 开始视频拉流，获取远端视频YUV数据
     * YUV数据见 VideoObserver::onRemoteVideoFrame
     */
    private void startPullVideoData(RtcContext context) {
        if (context.isPullVideoStarted) {
            return;
        }
        if (context.videoObserver != null) {
            context.videoObserver = null;
        }
        if (context.engine != null) {
            // 1. 创建视频数据输出observer，并注册到engine中
            context.videoObserver = new VideoObserver(context);
            context.engine.registerVideoFrameObserver(context.videoObserver);

            // 2. 开启视频数据订阅位置（支持'|'操作同时开启多个位置）
            context.engine.enableVideoFrameObserver(true,
                    DingRtcEngine.DingRtcVideoObservePosition.DingRtcPositionPreRender);
        }
        context.isPullVideoStarted = true;
    }

    /**
     * 初始化引擎
     */
    private void initRtcEngine(RtcContext context) {
        String dir = System.getProperty("user.dir");
        // 设置日志路径
        DingRtcEngine.setLogDirPath(dir);
        // 初始化回调
        RtcListener listener = new RtcListener(context);
        // 初始化引擎
        DingRtcEngine engine = DingRtcEngine.createInstance(listener, "");

        context.engine = engine;
        context.listener = listener;
    }

    /**
     * TODO request from app server
     * @return DingRtcAuthInfo
     */
    private DingRtcEngine.DingRtcAuthInfo getAuthInfoFromServer(RtcContext context) {
        DingRtcEngine.DingRtcAuthInfo authInfo = new DingRtcEngine.DingRtcAuthInfo();
        authInfo.appId = "";
        authInfo.channelId = "";
        authInfo.userId = "";
        authInfo.token = "";
        // 注意 gslb字段推荐填空串
        authInfo.gslb = "";
        return authInfo;
    }
}