package com.dingzhuo.compute.engine.utils;

import com.dingzhuo.compute.engine.message.alarm.AlarmStatus;
import com.dingzhuo.compute.engine.message.device.DeviceStatus;
import com.dingzhuo.energy.common.utils.StringUtils;
import com.dingzhuo.energy.common.utils.time.TimeType;
import com.dingzhuo.energy.data.model.domain.IndexStorage;
import com.dingzhuo.energy.data.model.domain.LimitType;
import com.dingzhuo.energy.data.monitoring.alarm.domain.AlarmItem;
import com.dingzhuo.energy.data.monitoring.device.domain.DeviceFormula;
import com.dingzhuo.energy.dataservice.domain.TagValue;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class CacheService {

  private final Logger logger = LoggerFactory.getLogger(this.getClass());
  private ConcurrentHashMap<String, IndexStorage> indexStorageCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, List<String>> postIndexIdsCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, AlarmItem> alarmItemCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, AlarmStatus> alarmCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, LimitType> limitTypeCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, TagValue> tagValueCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, DeviceFormula> deviceFormulaCache = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, DeviceStatus> deviceStatusCache = new ConcurrentHashMap<>();

  private ConcurrentHashMap<TimeType, Set<String>> registers = new ConcurrentHashMap<>();

  /**
   * 缓存指标存储信息.
   *
   * @param indexStorage 指标存储
   */
  public void cacheIndexStorage(IndexStorage indexStorage) {
    String actorId = ActorUtil.buildActorId(indexStorage);
    indexStorageCache.put(actorId, indexStorage);
  }

  /**
   * 根据 actorId 获取指标存储.
   *
   * @param actorId
   * @return
   */
  public IndexStorage getIndexStorageCache(String actorId) {
    return indexStorageCache.getOrDefault(actorId, null);
  }

  /**
   * 缓存计算指标的后置指标.
   *
   * @param actorId
   * @param postId
   */
  public void cachePostIndex(String actorId, String postId) {
    if (!postIndexIdsCache.containsKey(actorId)) {
      postIndexIdsCache.put(actorId, new ArrayList<>());
    }

    postIndexIdsCache.get(actorId).add(postId);
  }

  /**
   * 移除后置指标.
   *
   * @param actorId
   * @param postActorId
   */
  public void removePostIndexCache(String actorId, String postActorId) {
    if (!postIndexIdsCache.containsKey(actorId)) {
      postIndexIdsCache.put(actorId, new ArrayList<>());
    }

    postIndexIdsCache.get(actorId).remove(postActorId);
  }

  /**
   * 获取后置指标actorId.
   *
   * @param actorId
   * @return
   */
  public List<String> getPostActorIds(String actorId) {
    return postIndexIdsCache.getOrDefault(actorId, new ArrayList<>());
  }

  public void cacheAlarmItem(AlarmItem alarmItem) {
    String actorId = ActorUtil.buildAlarmActorId(alarmItem);
    alarmItemCache.put(actorId, alarmItem);
  }

  public void removeAlarmCache(String actorId) {
    alarmItemCache.remove(actorId);
  }

  public void removeIndexCache(String actorId) {
    indexStorageCache.remove(actorId);
  }

  public AlarmItem getAlarmItem(String actorId) {
    return alarmItemCache.getOrDefault(actorId, null);
  }

  public void cacheAlarmStatus(String indexId, String timeType, String limitType,
      AlarmStatus status) {
    String statusId = ActorUtil.buildAlarmStatusId(indexId, timeType, limitType);
    alarmCache.put(statusId, status);
  }

  public void cacheAlarmStatus(String statusId, AlarmStatus status) {
    alarmCache.put(statusId, status);
  }

  public AlarmStatus getAlarmStatus(String indexId, String timeType, String limitType) {
    String statusId = ActorUtil.buildAlarmStatusId(indexId, timeType, limitType);
    return alarmCache.getOrDefault(statusId, null);
  }

  public void cacheTagValues(List<TagValue> tagValues) {
    tagValues.forEach(tagValue -> tagValueCache.put(tagValue.getTagCode(), tagValue));
  }

  public void cacheLimitType(String limitCode, LimitType type) {
    limitTypeCache.put(limitCode, type);
  }

  public LimitType getLimitType(String limitType) {
    return limitTypeCache.getOrDefault(limitType, null);
  }

  public void cacheTagValue(TagValue tagValue) {
    if (tagValue == null) {
      return;
    }

    tagValueCache.put(tagValue.getTagCode(), tagValue);
  }

  public TagValue getTagValue(String indexCode) {
    if (StringUtils.isBlank(indexCode)) {
      return null;
    }

    return tagValueCache.getOrDefault(indexCode, null);
  }

  public void cacheDeviceStatusSetting(DeviceFormula deviceFormula) {
    if (deviceFormula != null) {
      String actorId = ActorUtil.buildActorId(deviceFormula);
      deviceFormulaCache.put(actorId, deviceFormula);
    }
  }

  public void removeDeviceStatusSetting(String actorId) {
    deviceFormulaCache.remove(actorId);
  }

  public DeviceFormula getDeviceFormula(String actorId) {
    return deviceFormulaCache.getOrDefault(actorId, null);
  }

  public DeviceStatus getDeviceStatus(String actorId) {
    return deviceStatusCache.getOrDefault(actorId, null);
  }

  public void cacheDeviceStatus(String actorId, DeviceStatus lastStatus) {
    deviceStatusCache.put(actorId, lastStatus);
  }

  public ConcurrentHashMap<TimeType, Set<String>> getRegisters() {
    return registers;
  }
}