package com.ckkj.water.device;

import static android.view.View.GONE;
import static android.view.View.VISIBLE;

import android.Manifest;
import android.content.Intent;
import android.graphics.drawable.AnimationDrawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;

import com.ckkj.water.ConstantUtil;
import com.ckkj.water.R;
import com.ckkj.water.base.BaseActivity;
import com.ckkj.water.databinding.DeviceResetWifiBinding;
import com.ckkj.water.device.adapter.WifiListAdapter;
import com.ckkj.water.device.mvp.DeviceContract;
import com.ckkj.water.device.mvp.DeviceImpl;
import com.ckkj.water.device.mvp.DevicePresenter;
import com.ckkj.water.espBle.EspProvisionManager;
import com.ckkj.water.espBle.ProvisionCallback;
import com.espressif.provisioning.WiFiAccessPoint;
import com.espressif.provisioning.listeners.WiFiScanListener;
import com.ckkj.water.index.entity.WaterDeviceEntity;
import com.ckkj.water.network.BaseBean;
import com.ckkj.water.permission.PermissionActivity;
import com.ckkj.water.utils.manager.ActivityManager;
import com.ckkj.water.utils.manager.ThemeManager;
import com.ckkj.water.utils.show.ToastUtil;
import com.gyf.immersionbar.ImmersionBar;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;

/**
 * 配置wifi
 */
public class SelectWifiActivity extends BaseActivity<DeviceResetWifiBinding, DevicePresenter>
    implements DeviceContract.DeviceView {

    private WifiListAdapter wifiListAdapter;
    //100 来自设备添加，   200 来自设备信息
    private int WITCH_FROM_CODE = 100;

    private String mWifiName = "";

    private WaterDeviceEntity mBleDeviceEntity;
    private WaterDeviceEntity mRemoteDeviceEntity;
    private EspProvisionManager espProvisionManager;
    private boolean isBleConnecting = false;
    private boolean isBleConnected = false;
    private boolean keepBleConnectionForProvision = false;
    private Handler bleConnectHandler = new Handler();
    private AnimationDrawable animationDrawable;
    private Handler handler = new Handler(Looper.getMainLooper());

    @Override
    public DevicePresenter createPresenter() {
        return new DevicePresenter(new DeviceImpl());
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityManager.addActivity(this,getClass().getSimpleName() + "_" + ConstantUtil.ADD_DEVICE_FLAG);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        bleConnectHandler.removeCallbacksAndMessages(null);
        if (WITCH_FROM_CODE == 100 && espProvisionManager != null && !keepBleConnectionForProvision) {
            espProvisionManager.disconnect();
            espProvisionManager.setCallback(null);
        }
    }

    @Override
    public void initData(Bundle savedInstanceState) {
        super.initData(savedInstanceState);
        Bundle bundle = getIntent().getExtras();
        if(bundle != null){
            WITCH_FROM_CODE = bundle.getInt(ConstantUtil.ACTIVITY_NAVIGATE_FLAG);
            mBleDeviceEntity = (WaterDeviceEntity) bundle.getSerializable("ble_device_entity");
        }

        ImmersionBar.with(this)
                .statusBarColor(R.color.color_gray_theme)
                .statusBarDarkFont(ThemeManager.isAppThemeLight(mContext))
                .titleBar(viewBinding.rlTitle)
                .init();
        if(WITCH_FROM_CODE == 200){
            viewBinding.tvNext.setText(getString(R.string.confirm_text));
        }
        viewBinding.includedTitle.tvTitle.setText(R.string.select_wifi_tip);

        initListener();
        initWifiList();
        if (WITCH_FROM_CODE == 100) {
            initEspProvision();
            scheduleBleConnect();
        }
    }


    private void startConnectAnimation() {
        if (animationDrawable != null && animationDrawable.isRunning()) {
            animationDrawable.stop();
        }

        viewBinding.ivConnectAnimation.setImageResource(R.drawable.anim_connect_ble_device);
        animationDrawable = (AnimationDrawable) viewBinding.ivConnectAnimation.getDrawable();

        if (animationDrawable != null) {
            animationDrawable.start();
        }
    }

    private void stopConnectAnimation() {
        handler.removeCallbacksAndMessages(null);
        if (animationDrawable != null) {
            animationDrawable.stop();
            animationDrawable = null;
        }
        viewBinding.linearConnectBle.setVisibility(GONE);
        viewBinding.linearWifiContent.setVisibility(VISIBLE);
    }


    private void initWifiList() {
        wifiListAdapter = new WifiListAdapter(mContext);
        viewBinding.rvWifiList.setAdapter(wifiListAdapter);
        wifiListAdapter.setOnWifiItemClickListener(wifiName -> {
            mWifiName = wifiName;
            viewBinding.etWifiName.setText(wifiName);
            viewBinding.rvWifiList.setVisibility(View.GONE);
            viewBinding.linearWifiInfo.setVisibility(View.VISIBLE);
            viewBinding.tvNext.setVisibility(View.VISIBLE);
        });
    }

    private void initListener() {
        setClick(viewBinding.includedTitle.imgBack);
        setClick(viewBinding.tvSelectWifi);
        setClick(viewBinding.tvNext);
    }

    private void setClick(View view) {
        view.setOnClickListener(this::onClick);
    }

    public void onClick(View view){
        switch (view.getId()){
            case R.id.img_back:
                finish();
                break;

            case R.id.tv_select_wifi:
                String[] permission = {
                        Manifest.permission.ACCESS_FINE_LOCATION
                };
                boolean hasPermission = hasRecordPermission(permission);
                if(!hasPermission){
                    goTo(mContext, PermissionActivity.class,null);
                    return;
                }
                scanWifi();
                break;

            case R.id.tv_next:
                if(TextUtils.isEmpty(mWifiName)){
                    ToastUtil.showShort(mContext,getString(R.string.toast_select_wifi_tip));
                    return;
                }
                if(TextUtils.isEmpty(viewBinding.etInputPsd.getText().toString())){
                    ToastUtil.showShort(mContext,getString(R.string.toast_select_wifi_psd_tip));
                    return;
                }
                String wifiPassword = viewBinding.etInputPsd.getText().toString();
                if(WITCH_FROM_CODE == 100){
                    goToDeviceConnect(wifiPassword);
                }else{
                    Intent intent = new Intent();
                    intent.putExtra("wifi_name",mWifiName);
                    intent.putExtra("wifi_psd",wifiPassword);
                    setResult(RESULT_OK,intent);
                    finish();
                }
                break;
        }
    }

    private void goToDeviceConnect(String wifiPassword) {
        if (espProvisionManager == null) {
            initEspProvision();
        }
        if (mBleDeviceEntity == null) {
            ToastUtil.showShort(mContext, getString(R.string.device_not_initialized));
            return;
        }
        isBleConnected = espProvisionManager != null && espProvisionManager.isConnected();
        if (!isBleConnected) {
            if (!isBleConnecting) {
                scheduleBleConnect();
            }
            ToastUtil.showShort(mContext, getString(R.string.device_connecting_please_wait));
            return;
        }

        Bundle bundle = new Bundle();
        bundle.putString("wifi_name", mWifiName);
        bundle.putString("wifi_password", wifiPassword);
        bundle.putSerializable("ble_device_entity", mBleDeviceEntity);
        keepBleConnectionForProvision = true;
        goTo(mContext, DeviceConnectActivity.class, bundle);
        finish();
    }



    private void initEspProvision() {
        espProvisionManager = EspProvisionManager.init(mContext).setCallback(new ProvisionCallback() {
            @Override
            public void onConnecting() {
                isBleConnecting = true;
                isBleConnected = false;
                Log.i("TEST","onConnecting");
            }

            @Override
            public void onConnected() {
                isBleConnecting = false;
                isBleConnected = true;
                Log.i("TEST","onConnected设备连接成功");
                stopConnectAnimation();
                ToastUtil.showShort(mContext, getString(R.string.device_connected_success));
                //Tips 蓝牙扫描添加的设备不同于二维码扫描连接的设备，由于无法拿到deviceNo，所以需要请求接口获取
                mPresenter.bindDeviceStatus(mBleDeviceEntity);
            }

            @Override
            public void onProvisioning(int progress) {
                Log.i("TEST","WIFI连接进度 == " +  progress);
                mProgressLoadingDialog.setProgress(progress);
            }

            @Override
            public void onSuccess(String deviceName, String deviceType) {
                Log.i("TEST","deviceName：" + deviceName + "连接成功");
                ToastUtil.showShort(mContext, getString(R.string.connection_success));
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        hideDialogLoading();
                    }
                }, 800);
            }

            @Override
            public void onFailed(int errorCode, String message) {
                isBleConnecting = false;
                if (errorCode != 0) {
                    isBleConnected = espProvisionManager != null && espProvisionManager .isConnected();
                }
                Log.i("TEST","errorCode == " + errorCode + " message == " + message);
                ToastUtil.showShort(mContext, message);
                stopConnectAnimation();
                finish();
            }

            @Override
            public void onDisconnected() {
                isBleConnecting = false;
                isBleConnected = false;
                stopConnectAnimation();
                Log.i("TEST","onDisconnected");
                ToastUtil.showShort(mContext, getString(R.string.device_disconnected));
            }

            @Override
            public void onWifiListReceived(String[] wifiList) {
                Log.i("TEST","onWifiListReceived-Msg==" + wifiList.toString());
            }

            @Override
            public void onWifiListFailed(String message) {
                Log.i("TEST","onWifiListFailed-Msg==" + message);
            }

            @Override
            public void onProvisioningRejected() {
                Log.i("TEST","onProvisioningRejected");
            }
        });
    }

    /**
     * 连接设备
     */
    private void scheduleBleConnect() {
        startConnectAnimation();
        bleConnectHandler.removeCallbacksAndMessages(null);
        bleConnectHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                connectBleDevice();
            }
        }, 1000);
    }

    private void connectBleDevice() {
        if (WITCH_FROM_CODE != 100 || mBleDeviceEntity == null || espProvisionManager == null) {
            return;
        }
        if (isBleConnected || isBleConnecting) {
            return;
        }
        espProvisionManager.connect(mBleDeviceEntity.getMacAddress().toUpperCase(Locale.ROOT),
                mBleDeviceEntity.getDeviceName());
    }

    private void scanWifi() {
        showLoadingDialog();
        viewBinding.tvNext.setVisibility(View.GONE);

        if (espProvisionManager == null || !espProvisionManager.isConnected()) {
            ToastUtil.showShort(mContext, getString(R.string.device_not_connected_retry));
            hideDialogLoading();
            return;
        }

        espProvisionManager.scanWifiFromDevice(new WiFiScanListener() {

            @Override
            public void onWifiListReceived(ArrayList<WiFiAccessPoint> wifiList) {
                runOnUiThread(() -> displayWifiListFromDevice(wifiList));
            }

            @Override
            public void onWiFiScanFailed(Exception e) {
                runOnUiThread(() -> {
                    ToastUtil.showShort(mContext, getString(R.string.scan_failed) + e.getMessage());
                    hideDialogLoading();
                });
            }

        });
    }

    private void displayWifiListFromDevice(ArrayList<WiFiAccessPoint> wifiNetworks) {
        Set<String> wifiSet = new HashSet<>();
        List<String> wifiNameList = new ArrayList<>();

        for (WiFiAccessPoint network : wifiNetworks) {
            String wifiName = network.getWifiName();
            if (wifiName != null && !wifiName.isEmpty() && !wifiSet.contains(wifiName)) {
                wifiSet.add(wifiName);
                wifiNameList.add(wifiName);
            }
        }
        hideDialogLoading();

        if (wifiNameList.isEmpty()) {
            ToastUtil.showShort(mContext, getString(R.string.no_wifi_found));
            viewBinding.linearWifiInfo.setVisibility(View.VISIBLE);
            viewBinding.rvWifiList.setVisibility(View.GONE);
        } else {
            wifiListAdapter.setData(wifiNameList);
            viewBinding.linearWifiInfo.setVisibility(View.GONE);
            viewBinding.rvWifiList.setVisibility(View.VISIBLE);
        }
    }


    @Override
    public void queryDeviceBindStatusSuccess(WaterDeviceEntity bean) {
        mBleDeviceEntity = bean.getBindDevice();
    }

    @Override
    public void queryDeviceWorkTimeSuccess(WaterDeviceEntity bean) {

    }

    @Override
    public void addDeviceSuccess(WaterDeviceEntity bean) {

    }

    @Override
    public void getDeviceDetailInfo(WaterDeviceEntity bean) {

    }

    @Override
    public void editDeviceInfoSuccess(BaseBean bean) {

    }

    @Override
    public void deleteDeviceSuccess(BaseBean bean) {

    }

    @Override
    public void turnOnOffDeviceSuccess(BaseBean bean, String status) {

    }


    @Override
    public int getLayoutResId(Bundle savedInstanceState) {
        return 0;
    }

    @Override
    public void showError(String message) {
        ToastUtil.showShort(mContext,message);
    }

    @Override
    public void logOut(BaseBean bean) {

    }
}