package com.ld.igds.protocol.easymedia;

import com.alibaba.fastjson.JSONObject;
import com.ld.igds.camera.data.ApiCameraData;
import com.ld.igds.camera.CameraUtil;
import com.ld.igds.camera.data.ApiCameraResp;
import com.ld.igds.camera.data.ApiSnapReq;
import com.ld.igds.protocol.snap.SnapPluginService;
import com.ld.igds.sec.dto.SecCameraDto;
import com.ld.igds.camera.ApiCameraService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Component
public class EasyGbsService implements ApiCameraService {

    public static String URL_PLAY = "http://ip:port/api/v1/stream/start";

    public static String URL_PTZ = "http://ip:port/api/v1/ptz/control";

    public static String URL_TOUCH = "http://ip:port/api/v1/stream/touch";

    public static String URL_PRESET = "http://ip:port/api/v1/preset/control";

    public static String URL_SNAP = "http://ip:port/api/v1/device/channelsnap";

    public static String URL_PLAY_HTML = "http://ip:port/play.html";

    /**
     * 设备上下线消息获取
     */
    public static String URL_STATUS = "http://ip:port/api/v1/news/list";

    @Autowired
    private SnapPluginService snapPluginService;
    @Autowired
    private EasyProp prop;
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public String getPlayType() {
        return CameraUtil.PLAY_TYPE_EASY_GBS;
    }

    @Override
    public ApiCameraResp getPlayAddr(ApiCameraData apiCameraDto) {
        try {
            String mediaIp = prop.getGbsIp();
            String mediaWanIp = prop.getGbsWanIp();

            if (StringUtils.isEmpty(mediaIp)) {
                log.warn("-----------没有获取到多媒体服务地址-----");
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "没有获取到多媒体服务地址");
            }

            String sn = apiCameraDto.getSn();

            URL_PLAY = URL_PLAY.replace("ip", mediaIp).replace("port",
                    prop.getGbsPort() + "");

            String code = sn;
            if (sn.indexOf("_") > 0) {
                code = sn.substring(sn.indexOf("_") + 1);
                sn = sn.substring(0, sn.indexOf("_"));
            }

            //如果使用IFRAME播放
            ApiCameraResp result1 = new ApiCameraResp();


            if (StringUtils.isNotEmpty(mediaWanIp)) {
                URL_PLAY_HTML = URL_PLAY_HTML.replace("ip", mediaWanIp).replace("port",
                        prop.getGbsPort() + "");
            } else {
                URL_PLAY_HTML = URL_PLAY_HTML.replace("ip", mediaIp).replace("port",
                        prop.getGbsPort() + "");
            }
            String iframeUrl = URL_PLAY_HTML + "?serial=" + sn + "&code=" + code + "&iframe=yes&showConsole=yes";

            result1.setPlayIframe(iframeUrl);
            result1.setCode("SUCCESS");

            log.info("-------获取多媒体播放信息---------result-{}", result1);

            //默认调用播放器播放

            String url = URL_PLAY + "?serial={serial}&code={code}";

            log.info("-------获取多媒体播放信息---------URL-{}", url);
            Map<String, String> map = new HashMap<>();
            map.put("serial", sn);
            map.put("code", code);

            ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                    url, String.class, map);

            String result = responseEntity.getBody();

            log.info("-------获取多媒体播放信息---------result-{}", result);

            if (result.indexOf("Error") > 0) {
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "调用流媒体接口返回异常");
            }

            JSONObject resultEntity = JSONObject.parseObject(result);

            String flv = (String) resultEntity.get("FLV");
            if (StringUtils.isNotEmpty(mediaWanIp)) {
                flv = flv.replace(mediaIp, mediaWanIp);
            }

            result1.setPlayAddr(flv);
            result1.setCode("SUCCESS");

            log.info("-------获取多媒体播放信息---------MediaResult-{}", result1);

            return result1;

        } catch (Exception e) {
            log.debug("调用流媒体服务器异常：{}", e);
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR,
                    "调用流媒体服务器异常：请联系管理员查看原因");
        }
    }

    /**
     * 云台控制
     * <p>
     * 执行命令 1=上，2=下，3=左，4=右，5=左上，6=左下，7=右上，8=右下，0=停止，9=变倍小，10 = 变倍加
     * <p>
     * 控制指令允许值: left, right, up, down, upleft, upright, downleft, downright,
     * zoomin, zoomout, stop
     *
     * @param dto
     * @return
     */
    @Override
    public ApiCameraResp ptzMedia(ApiCameraData dto) {

        if (StringUtils.isEmpty(dto.getSn()) && StringUtils.isEmpty(dto.getIp())) {
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "没有获取到当前摄像机IP/SN，不支持云台控制");

        }

        try {
            String mediaIp = prop.getGbsIp();

            if (null == mediaIp) {
                log.warn("-----------没有获取到多媒体服务地址-----");
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "没有获取到多媒体服务地址");
            }

            URL_PTZ = URL_PTZ.replace("ip", mediaIp).replace("port",
                    prop.getGbsPort() + "");

            String sn = dto.getSn();
            String code = sn;
            if (sn.indexOf("_") > 0) {
                code = sn.substring(sn.indexOf("_") + 1);
                sn = sn.substring(0, sn.indexOf("_"));
            }

            String url = URL_PTZ
                    + "?serial={serial}&code={code}&command={command}";

            log.info("-------调用流媒体PTZ路径---------URL-{},command={}", url,
                    dto.getCommand());

            // 命令进行转换 控制指令 允许值: left, right, up, down, upleft, upright,
            // downleft, downright, zoomin, zoomout, stop
            if ("1".equals(dto.getCommand())) {
                dto.setCommand("up");
            }
            if ("2".equals(dto.getCommand())) {
                dto.setCommand("down");
            }
            if ("3".equals(dto.getCommand())) {
                dto.setCommand("left");
            }
            if ("4".equals(dto.getCommand())) {
                dto.setCommand("right");
            }
            if ("5".equals(dto.getCommand())) {
                dto.setCommand("upleft");
            }
            if ("6".equals(dto.getCommand())) {
                dto.setCommand("downleft");
            }
            if ("7".equals(dto.getCommand())) {
                dto.setCommand("upright");
            }
            if ("8".equals(dto.getCommand())) {
                dto.setCommand("downright");
            }
            if ("9".equals(dto.getCommand())) {
                dto.setCommand("zoomin");
            }
            if ("10".equals(dto.getCommand())) {
                dto.setCommand("zoomout");
            }
            if ("0".equals(dto.getCommand())) {
                dto.setCommand("stop");
            }

            Map<String, String> map = new HashMap<>();
            map.put("serial", sn);
            map.put("code", code);
            map.put("command", dto.getCommand());

            ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                    url, String.class, map);

            String result = responseEntity.getBody();

            log.info("-------流媒体调用结果---执行-{}------result-{}", dto.getCommand(),
                    result);

            if (HttpStatus.OK == responseEntity.getStatusCode()) {
                return new ApiCameraResp(ApiCameraResp.CODE_SUCCESS, "云台执行成功");
            } else {
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "云台执行失败");
            }
        } catch (Exception e) {

            log.debug("调用流媒体服务器异常：{}", e);
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "异常提醒：操作过于频繁");

        }
    }

    /**
     * 预置位置执行
     * <p>
     * 允许值: set, goto, remove
     *
     * @param dto
     * @return
     */
    @Override
    public ApiCameraResp ptzPreset(ApiCameraData dto) {

        if (StringUtils.isEmpty(dto.getSn()) && StringUtils.isEmpty(dto.getIp())) {
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "没有获取到当前摄像机IP/SN，不支持云台控制");

        }

        try {
            String mediaIp = prop.getGbsIp();

            if (null == mediaIp) {
                return null;
            }

            URL_PRESET = URL_PRESET.replace("ip", mediaIp).replace("port",
                    prop.getGbsPort()+"");

            String sn = dto.getSn();
            String code = sn;
            if (sn.indexOf("_") > 0) {
                code = sn.substring(sn.indexOf("_") + 1);
                sn = sn.substring(0, sn.indexOf("_"));
            }

            String url = URL_PRESET
                    + "?serial={serial}&code={code}&command={command}&preset={preset}";

            if ("1".equals(dto.getCommand())) {
                dto.setCommand("set");
            }
            if ("2".equals(dto.getCommand())) {
                dto.setCommand("goto");
            }
            if ("3".equals(dto.getCommand())) {
                dto.setCommand("remove");
            }

            log.info("-------获取多媒体预置位控制信息---------URL-{}", url);
            Map<String, String> map = new HashMap<>();
            map.put("serial", sn);
            map.put("code", code);
            map.put("command", dto.getCommand());
            map.put("preset", dto.getPreset());

            ResponseEntity<String> responseEntity = restTemplate.getForEntity(
                    url, String.class, map);

            if (HttpStatus.OK == responseEntity.getStatusCode()) {
                return new ApiCameraResp(ApiCameraResp.CODE_SUCCESS, "执行成功");
            } else {
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR, responseEntity.getBody());
            }
        } catch (Exception e) {

            log.error("调用流媒体服务器异常：{}", e);
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "后台执行异常");
        }
    }

    @Override
    public ApiCameraResp keepAlive(ApiCameraData apiCameraDto) {

        if (StringUtils.isEmpty(apiCameraDto.getSn()) && StringUtils.isEmpty(apiCameraDto.getIp())) {
            return new ApiCameraResp(ApiCameraResp.CODE_ERROR, "没有获取到当前摄像机IP/SN，不支持云台控制");
        }

        try {
            String mediaIp = prop.getGbsIp();

            if (null == mediaIp) {
                return new ApiCameraResp(ApiCameraResp.CODE_ERROR,
                        "流媒体保活失败！");
            }

            URL_TOUCH = URL_TOUCH.replace("ip", mediaIp).replace("port",
                    prop.getGbsPort()+"");

            String sn = apiCameraDto.getSn();
            String code = sn;
            if (sn.indexOf("_") > 0) {
                code = sn.substring(sn.indexOf("_") + 1);
                sn = sn.substring(0, sn.indexOf("_"));
            }

            String url = URL_TOUCH + "?serial={serial}&code={code}";

            log.info("-------流媒体保活---------URL-{}", url);
            Map<String, String> map = new HashMap<>();
            map.put("serial", sn);
            map.put("code", code);

            restTemplate.getForObject(url, Object.class, map);

        } catch (Exception e) {
            log.error("调用流媒体服务器异常：{}", e);
        }
        return new ApiCameraResp(ApiCameraResp.CODE_SUCCESS,
                "流媒体保活！");
    }

    @Override
    public List<SecCameraDto> searchCamera(ApiCameraData apiCameraDto) {
        //TODO
        return null;
    }

    @Override
    public ApiCameraResp snapImg(ApiSnapReq apiCameraDto) {

        if (CameraUtil.SNAP_TYPE_FZZY_PLUGIN.equals(apiCameraDto.getSnapType())) {
            return snapPluginService.snapImg(apiCameraDto);
        }
        return null;
    }
}