package com.basic.security.manager;

import android.os.SystemClock;

import com.basic.security.base.BaseApplication;
import com.basic.security.model.ModelAdapter;
import com.basic.security.model.Outdoor;
import com.basic.security.utils.Constants;
import com.basic.security.utils.ExceptionUtil;
import com.basic.security.utils.FragmentUtil;
import com.basic.security.utils.socket.indoor.IndoorGuestSocketClient;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RemoteOutdoorManager extends BaseManager {
    public static List<ModelAdapter> outdoorList = new ArrayList<>();
    public static Map<String, ModelAdapter> outdoorByOutDeviceIdMap = new HashMap<>();
    public static Map<String, ModelAdapter> outdoorByOutDeviceIpMap = new HashMap<>();
    public static Lock outdoorListLock = new ReentrantLock();
    public static IndoorGuestSocketClient guestSocketClient1 = null;
    public static IndoorGuestSocketClient guestSocketClient2 = null;
    public static List<IndoorGuestSocketClient> guestSocketClientList = new ArrayList();
    public static boolean useIp = false;

    public static void startNewSocketClient() {
        int guestListCameraType = 1;
        if (Constants.indoorOutdoorInOne) {
            guestListCameraType = 2;
        }
        RemoteOutdoorManager.guestSocketClient1 = new IndoorGuestSocketClient("", FragmentUtil.guestModeFragment().camera1, guestListCameraType);
        RemoteOutdoorManager.guestSocketClient1.start();
        guestSocketClientList.add(RemoteOutdoorManager.guestSocketClient1);
        SystemClock.sleep(10 * 1000);
    }

    public static void initTwoOutdoors() {
        if (Constants.isIndoor) {
            RemoteOutdoorManager.initGuestSocketClients();
            {
                ModelAdapter outdoor1 = RemoteOutdoorManager.findById(Outdoor.tableName, "outdoor1");
                if (outdoor1 == null) {
                    outdoor1 = new ModelAdapter();
                }
                outdoor1.setString(Outdoor.id, "outdoor1");
                outdoor1.setString(Outdoor.outdoor_device_name, "outdoor1");
                outdoor1.setString(Outdoor.outdoor_device_id, "outdoor1");
                outdoor1.setString(Outdoor.valid, Constants.TRUE);
                outdoor1.setString(Outdoor.update_time, System.currentTimeMillis() + "");
                outdoor1.setString(Constants.TABLE, Outdoor.tableName);
                save(outdoor1);
            }
            RemoteOutdoorManager.findOutdoorList();
            BaseApplication.getApplication().executorService.execute(() -> {
                while (true) {
                    try {
                        try {
                            List<IndoorGuestSocketClient> socketClientListToRemove = new ArrayList<>();
                            for (IndoorGuestSocketClient socketClient1 : guestSocketClientList) {
                                if (System.currentTimeMillis() - socketClient1.lastUpdateTime > 1000 * 60 * 1) {
                                    socketClient1.interrupt();
                                    socketClientListToRemove.add(socketClient1);
                                }
                            }
                            guestSocketClientList.removeAll(socketClientListToRemove);
                            if (guestSocketClientList.size() == 0) {
                                startNewSocketClient();
                            }
                        } catch (Exception e) {
                            System1.out.println("pullAlarmDataList, " + e.getMessage());
                        }
                    } catch (Exception e) {
                        ExceptionUtil.printException(e);
                    } finally {
                        SystemClock.sleep(3000);
                    }
                }
            });
            initGuestSocketClients();
        }
    }

    public static void initGuestSocketClients() {
        findOutdoorList();
        try {
            outdoorListLock.lock();
            if (guestSocketClient1 != null && guestSocketClient2 != null) {
                boolean updateGuestSocketClient1Return = updateGuestSocketClient1();
                boolean updateGuestSocketClient2Return = updateGuestSocketClient2();
                if (!updateGuestSocketClient1Return) {
                    initGuestSocketClient1();
                }
                if (!updateGuestSocketClient2Return) {
                    initGuestSocketClient2();
                }
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        } finally {
            outdoorListLock.unlock();
        }
    }

    public static boolean updateGuestSocketClient1() {
        try {
            ModelAdapter oldOutdoor = guestSocketClient1.outdoor;
            if (oldOutdoor != null) {
                String oldOutdoorDeviceId = oldOutdoor.getString(Outdoor.outdoor_device_id);
                String oldOutdoorDeviceIp = oldOutdoor.getString(Outdoor.outdoor_device_ip);
                ModelAdapter outdoorInMap = outdoorByOutDeviceIdMap.get(oldOutdoorDeviceId);
                if (outdoorInMap != null && Constants.TRUE.equals(outdoorInMap.getString(Outdoor.valid))) {
                    guestSocketClient1.outdoor = outdoorInMap;
                    return true;
                }
                if (outdoorInMap == null && useIp) {
                    outdoorInMap = outdoorByOutDeviceIpMap.get(oldOutdoorDeviceIp);
                    if (outdoorInMap != null && Constants.TRUE.equals(outdoorInMap.getString(Outdoor.valid))) {
                        guestSocketClient1.outdoor = outdoorInMap;
                        return true;
                    }
                }
                if (outdoorInMap != null) {
                    guestSocketClient1.outdoor = outdoorInMap;
                    return false;
                }
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        }
        return false;
    }

    public static boolean updateGuestSocketClient2() {
        try {
            ModelAdapter oldOutdoor = guestSocketClient2.outdoor;
            if (oldOutdoor != null) {
                String oldOutdoorDeviceId = oldOutdoor.getString(Outdoor.outdoor_device_id);
                String oldOutdoorDeviceIp = oldOutdoor.getString(Outdoor.outdoor_device_ip);
                ModelAdapter outdoorInMap = outdoorByOutDeviceIdMap.get(oldOutdoorDeviceId);
                if (outdoorInMap != null && Constants.TRUE.equals(outdoorInMap.getString(Outdoor.valid))) {
                    guestSocketClient2.outdoor = outdoorInMap;
                    return true;
                }
                if (outdoorInMap == null && useIp) {
                    outdoorInMap = outdoorByOutDeviceIpMap.get(oldOutdoorDeviceIp);
                    if (outdoorInMap != null && Constants.TRUE.equals(outdoorInMap.getString(Outdoor.valid))) {
                        guestSocketClient2.outdoor = outdoorInMap;
                        return true;
                    }
                }
                if (outdoorInMap != null) {
                    guestSocketClient2.outdoor = outdoorInMap;
                    return false;
                }
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        }
        return false;
    }

    public static void initGuestSocketClient1() {
        try {
            for (ModelAdapter outdoor : outdoorList) {
                if (outdoor != guestSocketClient2.outdoor) {
                    if (Constants.TRUE.equals(outdoor.getString(Outdoor.valid))) {
                        guestSocketClient1.outdoor = outdoor;
                        break;
                    }
                }
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        }
    }

    public static void initGuestSocketClient2() {
        try {
            for (ModelAdapter outdoor : outdoorList) {
                if (outdoor != guestSocketClient1.outdoor) {
                    if (Constants.TRUE.equals(outdoor.getString(Outdoor.valid))) {
                        guestSocketClient2.outdoor = outdoor;
                        break;
                    }
                }
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        }
    }

    public static List<ModelAdapter> findOutdoorList() {
        try {
            outdoorListLock.lock();
            outdoorList = findList("select * from " + Outdoor.tableName
                    + " order by " + Outdoor.outdoor_device_id + " ");
            outdoorByOutDeviceIdMap.clear();
            outdoorByOutDeviceIpMap.clear();
            for (ModelAdapter outdoor : outdoorList) {
                outdoorByOutDeviceIdMap.put(outdoor.getString(Outdoor.outdoor_device_id), outdoor);
                outdoorByOutDeviceIpMap.put(outdoor.getString(Outdoor.outdoor_device_ip), outdoor);
            }
        } catch (Exception e) {
            ExceptionUtil.printException(e);
        } finally {
            outdoorListLock.unlock();
        }
        return outdoorList;
    }

    public static void updateOutdoor(Map<String, Object> requestMap) {
        String outdoorDeviceId = (String) requestMap.get(Outdoor.outdoor_device_id);
        String outdoorDeviceIp = (String) requestMap.get(Outdoor.outdoor_device_ip);
        removeOutdoor();
        ModelAdapter outdoor = findOne("select * from " + Outdoor.tableName + " where " + Outdoor.outdoor_device_id + "='" + outdoorDeviceId + "' " +
                (useIp ? " or " + Outdoor.outdoor_device_ip + "='" + outdoorDeviceIp + "'" : ""));
        String valid = (String) requestMap.get(Outdoor.valid);
        if (outdoor == null) {
            outdoor = new ModelAdapter();
            outdoor.setIdWithUuid();
            outdoor.setString(Outdoor.device_id, DeviceManager.getDeviceId());
        }
        outdoor.setString(Outdoor.outdoor_device_id, outdoorDeviceId);
        outdoor.setString(Outdoor.outdoor_device_name, (String) requestMap.get(Outdoor.outdoor_device_name));
        outdoor.setString(Outdoor.outdoor_device_ip, outdoorDeviceIp);
        outdoor.setString(Outdoor.valid, valid);
        outdoor.setString("table", Outdoor.tableName);
        outdoor.setString(Outdoor.update_time, System.currentTimeMillis() + "");
        save(outdoor);
        initGuestSocketClients();
    }

    private static void removeOutdoor() {
        DatabaseManager.execSQL("delete from " + Outdoor.tableName);
    }

    public static List<String> getOutdoorDeviceIp() {
        List<String> remoteOutdoorIpList = new ArrayList<>();
        findOutdoorList();
        if (outdoorList != null && outdoorList.size() > 0) {
            for (ModelAdapter outdoor : outdoorList) {
                remoteOutdoorIpList.add(outdoor.getString(Outdoor.outdoor_device_ip));
            }
        }
        return remoteOutdoorIpList;
    }
}