package com.mogo.launcher;

import android.content.Context;
import android.content.Intent;
import android.os.Process;
import android.util.Log;

import com.auto.zhidao.logsdk.CrashSystem;
import com.bytedance.boost_multidex.BoostMultiDex;
import com.mogo.cloud.httpdns.MogoHttpDnsConfig;
import com.mogo.cloud.httpdns.bean.HttpDnsSimpleLocation;
import com.mogo.cloud.passport.IMoGoTokenCallback;
import com.mogo.cloud.passport.MoGoAiCloudClient;
import com.mogo.cloud.passport.MoGoAiCloudClientConfig;
import com.mogo.commons.AbsMogoApplication;
import com.mogo.commons.constants.SharedPrefsConstants;
import com.mogo.commons.debug.DebugConfig;
import com.mogo.commons.network.Utils;
import com.mogo.eagle.core.data.config.FunctionBuildConfig;
import com.mogo.eagle.core.data.constants.MogoServicePaths;
import com.mogo.map.MapApiPath;
import com.mogo.map.location.MogoLocation;
import com.mogo.module.carchatting.card.CallChatConstant;
import com.mogo.module.common.MogoApisHandler;
import com.mogo.module.common.MogoModule;
import com.mogo.module.common.MogoModulePaths;
import com.mogo.module.common.constants.HostConst;
import com.mogo.module.main.service.MogoMainService;
import com.mogo.module.push.base.PushUIConstants;
import com.mogo.module.service.ServiceConst;
import com.mogo.module.share.constant.ShareConstants;
import com.mogo.module.v2x.V2XConst;
import com.mogo.module.v2x.utils.ObuConfig;
import com.mogo.service.IMogoServiceApis;
import com.mogo.test.crashreport.CrashReportConstants;
import com.mogo.test.crashreport.upgrade.UpgradeReportConstants;
import com.mogo.utils.ProcessUtils;
import com.mogo.utils.logger.LogLevel;
import com.mogo.utils.logger.Logger;
import com.mogo.utils.storage.SharedPrefsMgr;
import com.zhidao.boot.persistent.lib.PersistentManager;

/**
 * @author congtaowang
 * @since 2019-12-18
 * <p>
 * Launcher application
 */
public class MogoApplication extends AbsMogoApplication {

    private static final String TAG = "MogoApplication";

    private long start;
//    private volatile static RefWatcher refWatcher;

    @Override
    public void onCreate() {
        initDebugConfig();
        super.onCreate();
        if (!shouldInit()) {
            return;
        }
        // Crash 日志收集
        start = System.currentTimeMillis();
        CrashSystem crashSystem = CrashSystem.getInstance(this);
        crashSystem.init();
        //设置debug模式，日志不上传
        //        crashSystem.setDebug(BuildConfig.DEBUG);
        Logger.init(BuildConfig.DEBUG ? LogLevel.DEBUG : LogLevel.OFF);
        initTipToast();
        initModules();
    }

    @Override
    protected boolean shouldInit() {
        Logger.w(TAG, "evaluate shouldInit() with: %s", ProcessUtils.getProcessName(Process.myPid()));
        return ProcessUtils.isMainProcess(this);
    }

    /**
     * BuildConfig中渠道配置赋值
     */
    private void initDebugConfig() {
        DebugConfig.setNetMode(BuildConfig.NET_ENV);
        DebugConfig.setDebug(BuildConfig.DEBUG);
        DebugConfig.setLaunchLocationService(BuildConfig.LAUNCH_LOCATION_SERVICE);
        DebugConfig.setUseCustomNavi(BuildConfig.USE_CUSTOM_NAVI);
        DebugConfig.setLauncher(BuildConfig.IS_LAUNCHER);
        DebugConfig.setActiveAIAssistFlag(BuildConfig.AI_ASSIST_ACTIVE_STAUTS);
        DebugConfig.setUseMockObuData(false);
        DebugConfig.setCarMachineType(BuildConfig.CAR_MACHINE_TYPE);
        DebugConfig.setProductFlavor(BuildConfig.FLAVOR_product);
        DebugConfig.setSocketAppId(BuildConfig.SOCKET_APP_ID);
        DebugConfig.setScheduleCalculateNotHomeCompanyDistanceForPush(BuildConfig.IS_SUPPORT_SCHEDULE_CALCULATE_NOT_HOME_COMPANY_DISTANCE_FOR_PUSH);
        DebugConfig.setMapBased(BuildConfig.IS_MAP_BASED);
        DebugConfig.setNeedHideAdasWhenShare(BuildConfig.IS_NEED_HIDE_ADAS_WHEN_SHARE);
        DebugConfig.setNeedUploadCoordinatesInTime(BuildConfig.IS_NEED_UPLOAD_COORDINATES_IN_TIME);
        DebugConfig.setObuType(SharedPrefsMgr.getInstance(this).getInt("OBU_TYPE", DebugConfig.OBU_TYPE_CIDI));

        ObuConfig.useObuLocation = false;
        // 使用与渠道配置一样的gps提供者提供的数据,app/productFlavors/fPadLenovo.gradle  GPS_PROVIDER  0-Android系统，1-工控机，2-OBU
        FunctionBuildConfig.gpsProvider = BuildConfig.GPS_PROVIDER;
        // 配置BuglyAppID
        CrashReportConstants.buglyAppID = "f3f8b0b2f1";
    }

    @Override
    protected void asyncInitImpl() {
        super.asyncInitImpl();
    }

    @Override
    protected void init() {
        super.init();
        prepareBaseService();
    }

    /**
     * 基础服务：passport、location、socket
     */
    private void prepareBaseService() {
        // 第三方平台的sn是由AI云SDK中服务调用通过服务端生成的
        preparePassportEnvironment();
    }

    private void preparePassportEnvironment() {
        // 配置云服务API
        MoGoAiCloudClientConfig clientConfig = MoGoAiCloudClientConfig.getInstance();
        // 设置网络环境：HTTP_DNS_ENV_QA、HTTP_DNS_ENV_RELEASE、HTTP_DNS_ENV_DEV
        switch (DebugConfig.getNetMode()) {
            case DebugConfig.NET_MODE_DEV:
                clientConfig.setNetMode(MogoHttpDnsConfig.HTTP_DNS_ENV_DEV);
                break;
            case DebugConfig.NET_MODE_QA:
                clientConfig.setNetMode(MogoHttpDnsConfig.HTTP_DNS_ENV_QA);
                break;
            case DebugConfig.NET_MODE_DEMO:
                clientConfig.setNetMode(MogoHttpDnsConfig.HTTP_DNS_ENV_DEMO);
                break;
            default:
                clientConfig.setNetMode(MogoHttpDnsConfig.HTTP_DNS_ENV_RELEASE);
        }
        // 设置是否是第三APP登录
        clientConfig.setThirdLogin(DebugConfig.getCarMachineType() != DebugConfig.CAR_MACHINE_TYPE_SELF_INNOVATE);
        // 设置是否输出日志
        clientConfig.setShowDebugLog(true);
        // 设置是否是直播推流的主播
        clientConfig.setAnchor(false);
        // 设置从蘑菇AI开放平台获取的APPKey
        switch (DebugConfig.getCarMachineType()) {
            // 自研车机
            case DebugConfig.CAR_MACHINE_TYPE_SELF_INNOVATE:
                clientConfig.setThirdPartyAppKey("wbvpzgar");
                break;
            // 比亚迪
            case DebugConfig.CAR_MACHINE_TYPE_BYD:
                clientConfig.setThirdPartyAppKey("bydauto");
                break;
            // 衡阳-鹰眼项目
            case DebugConfig.CAR_MACHINE_TYPE_LENOVO:
                clientConfig.setThirdPartyAppKey("pfieouqg");
                break;
        }
        // 设置应用服务AppId  长链、鉴权
        if (DebugConfig.getNetMode() == DebugConfig.NET_MODE_RELEASE) {
            clientConfig.setServiceAppId("com_mogo_launcher");
        } else {
            clientConfig.setServiceAppId("com.mogo.launcher");
        }
        // 设置AI云平台分配给三方应用的签名密钥，需要从AI云平台申请
        // 设置车机设备的唯一标识（这些表识必须是通过后台录入的设备）
        clientConfig.setThirdPartyDeviceId(Utils.getDevicesId());
        // 设置循环检测间隔时间
        clientConfig.setLoopCheckDelay(5 * 1000);

        clientConfig.setIHttpDnsCurrentLocation(() -> {
            MogoLocation mogoLocation =
                    MogoApisHandler.getInstance()
                            .getApis().getMapServiceApi()
                            .getSingletonLocationClient(getApp())
                            .getLastKnowLocation();
            HttpDnsSimpleLocation httpDnsSimpleLocation;
            if (mogoLocation != null
                    && mogoLocation.getLatitude() != 0
                    && mogoLocation.getLongitude() != 0) {
                httpDnsSimpleLocation = new HttpDnsSimpleLocation(
                        mogoLocation.getCityCode(),
                        mogoLocation.getLatitude(),
                        mogoLocation.getLongitude());
                Logger.i(TAG, "使用实时GPS信息：" + httpDnsSimpleLocation);
            } else {
                String ciyCode = SharedPrefsMgr.getInstance(getApp())
                        .getString(SharedPrefsConstants.LOCATION_CITY_CODE);
                String latitude = SharedPrefsMgr.getInstance(getApp())
                        .getString(SharedPrefsConstants.LOCATION_LATITUDE);
                String longitude = SharedPrefsMgr.getInstance(getApp())
                        .getString(SharedPrefsConstants.LOCATION_LONGITUDE);
                try {
                    httpDnsSimpleLocation = new HttpDnsSimpleLocation(
                            ciyCode,
                            Double.parseDouble(latitude),
                            Double.parseDouble(longitude));
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                    httpDnsSimpleLocation = new HttpDnsSimpleLocation("010", 1, 1);
                }
                Logger.i(TAG, "使用缓存GPS信息：" + httpDnsSimpleLocation);
            }
            return httpDnsSimpleLocation;
        });

        // 初始化SDK，可以设置状态回调来监听
        MoGoAiCloudClient.getInstance().init(this, clientConfig).addTokenCallbacks(
                new IMoGoTokenCallback() {
                    @Override
                    public void onTokenGot(String token, String sn) {
                        Logger.d("TEST-SOCKET", "onTokenGot ");
                        // 异步初始化NetConfig
                        asyncInit();
                        // HttpDns ttl回调 --- socketTTL
                        registerSocketHttpDnsTTL(HostConst.SOCKET_CENTER_DOMAIN);
                        // 开启每5s/次定位上报
                        uploadLocPerFiveSecond();
                    }

                    @Override
                    public void onError(int code, String msg) {
                        Log.d(TAG, "初始化MogoAiCloudSdk failed ,reason : " + msg + " , 未能开启长链服务和初始化Modules服务");
                    }
                }
        );
    }

    /**
     * TODO 这里定位数据有问题
     * 上传自车位置信息到云端
     */
    private void uploadLocPerFiveSecond() {
        if (DebugConfig.getCarMachineType() != DebugConfig.CAR_MACHINE_TYPE_SELF_INNOVATE) {
            IMogoServiceApis apis = MogoApisHandler.getInstance().getApis();
            apis.getLocationInfoApi().start();
            apis.getMapServiceApi().getSingletonLocationClient(getApplicationContext()).addLocationListener(location -> {
                apis.getLocationInfoApi().provideLocation(location);
            });
        }
    }

    private void startSocketService() {
        IMogoServiceApis apis = MogoApisHandler.getInstance().getApis();
        // 关闭长链服务
        apis.getSocketManagerApi(getApplicationContext()).destroy();
        // 开启Socket长链服务
        apis.getSocketManagerApi(getApplicationContext()).init(getApplicationContext(), DebugConfig.getSocketAppId());
    }

    @Override
    protected void socketTTL() {
        // 鉴权成功后开启socket长链服务
        startSocketService();
    }

    private void initModules() {
        Logger.d(TAG, "initModules");

        // 初始化 bugly 升级
        MogoModulePaths.addBaseModule(new MogoModule(UpgradeReportConstants.PATH, UpgradeReportConstants.NAME));
        // 初始化 bugly 日志采集
        MogoModulePaths.addBaseModule(new MogoModule(CrashReportConstants.PATH, CrashReportConstants.NAME));

        if (DebugConfig.isLauncher()) {
            MogoModulePaths.addModule(new MogoModule(MogoServicePaths.PATH_BACK, MogoServicePaths.PATH_BACK));
        }

        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_WIDGETS, MogoServicePaths.PATH_WIDGETS));
        if (DebugConfig.isMapBased()) {
            MogoModulePaths.addModule(new MogoModule(CallChatConstant.PROVIDER, CallChatConstant.MODULE_NAME));
        }

        MogoModulePaths.addBaseModule(new MogoModule(MapApiPath.PATH, "CustomMapApiBuilder"));
        MogoModulePaths.addBaseModule(new MogoModule(ServiceConst.PATH_TTS_CONFIG, ServiceConst.PATH_TTS_CONFIG));
        MogoModulePaths.addBaseModule(new MogoModule(ShareConstants.TAG, ShareConstants.MODEL_NAME));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_TANLU_API, "TanluApi"));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_TRAFFIC_UPLOAD, "TrafficUpload"));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_SHARE, "ShareControl"));
        MogoModulePaths.addBaseModule(new MogoModule(ServiceConst.PATH_REFRESH_STRATEGY, ServiceConst.PATH_REFRESH_STRATEGY));
        MogoModulePaths.addBaseModule(new MogoModule(V2XConst.PATH_V2X_UI, V2XConst.MODULE_NAME));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_STRATEGY_SHARE, "StrategyShare"));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_GAODE_AIMLESS_SHARE, "GaoDeAimlessShare"));
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_MOGO_MONITOR, "MogoMonitor"));

        // 域控制器模块（新）
        MogoModulePaths.addModuleFunctionServer(new MogoModule(MogoServicePaths.PATH_AUTO_PILOT, "IMoGoAutoPilotProvider"));
        // OBU 模块
        MogoModulePaths.addModuleFunctionServer(new MogoModule(MogoServicePaths.PATH_V2X_OBU_MOGO, "IMoGoObuProvider"));
        // 超视距，路测、行车记录仪监控
        MogoModulePaths.addModuleFunctionServer(new MogoModule(MogoServicePaths.PATH_AI_MONITORING, "IMoGoMonitoringProvider"));
        // 小地图模块
        MogoModulePaths.addModuleFunction(new MogoModule(MogoServicePaths.PATH_SMALL_MAP, "IMogoSmallMapProvider"));
        // widgets 模块
        MogoModulePaths.addModuleFunction(new MogoModule(MogoServicePaths.PATH_V2X_WARNING, "IMoGoWaringProvider"));

        // 自动驾驶系统检测模块
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_CHECK, "CheckProvider"));
        // 推送模块
        MogoModulePaths.addModule(new MogoModule(PushUIConstants.PATH, PushUIConstants.NAME));
        // 碰撞报警模块
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_CRASH_WARNING, "IMogoCrashWarnProvider"));
        // ADAS模块（旧，慢慢被 域控制器模块 替换掉）
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_ADAS, "AdasProvider"));
        // 前方碰撞预警
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_V2X_FRONT_CRASH_WARNING, "IV2XManagerProvider"));
        // 全局语音唤醒
        MogoModulePaths.addBaseModule(new MogoModule(MogoServicePaths.PATH_GLOBAL_UNWAKE, "GlobalUnwake"));
        // 云公告发布
        MogoModulePaths.addModuleFunction(new MogoModule(MogoServicePaths.PATH_AI_NOTICE, "IMoGoNoticeProvider"));

        if (!DebugConfig.isLauncher()) {
            PersistentManager.getInstance().initManager(this);
            Intent intent = new Intent(this, MogoMainService.class);
            startService(intent);
        }

//        if (refWatcher == null) {
//            refWatcher = LeakCanary.install(this);
//        }

        Log.i("timer", "cost " + (System.currentTimeMillis() - start) + "ms");
    }

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        BoostMultiDex.install(base);
    }
}