import BufferManagerWorker from "./BufferManagerWorker";
import ApiBufferKey from "./ApiBufferKey";
import Semaphore from "../common/utils/Semaphore";
import AgentConfig from "../common/data/AgentConfig";
import APISample from "../common/data/APISample";
import SimpleBuffer from "./SimpleBuffer";
import { postRequest } from "../common/utils/RequestExecutor";
import SDKLogger from "../SDKLogger";

class RegisteredApiBufferManagerWorker extends BufferManagerWorker<ApiBufferKey> {
  private readonly semaphore: Semaphore;
  constructor(config: AgentConfig, ctUrl: string) {
    super(config, ctUrl);
    this.semaphore = new Semaphore(this.getRegisteredApiCountToCapture());
  }
  init(): boolean {
    return true;
  }

  offer(key: ApiBufferKey, apiSample: APISample): boolean {
    this.bufferMap.computeIfAbsent(
      key,
      new SimpleBuffer(this.getRegisteredApiBufferSize(key))
    );
    let buffer: SimpleBuffer | undefined = this.bufferMap.getBuffer(key);
    if (!buffer) {
      return false;
    }
    return buffer.offer(apiSample);
  }

  canOffer(key: ApiBufferKey): boolean {
    if (!this.getOperatingConfig()?.getCaptureApiSample()) {
      return false;
    }
    let bufferSize: number = this.getRegisteredApiBufferSize(key);
    if (bufferSize === 0) {
      return false;
    }
    let buffer: SimpleBuffer | undefined = this.bufferMap.getBuffer(key);
    if (this.semaphore.tryAcquire()) {
      let canOffer: boolean;
      if (!buffer) {
        canOffer = true;
      } else {
        canOffer = buffer.canOffer();
      }
      this.semaphore.release();
      return canOffer;
    }
    return false;
  }

  getRegisteredApiBufferSize(apiBufferKey: ApiBufferKey): number {
    let agentConfig: AgentConfig | null = this.getOperatingConfig();
    if (!agentConfig) {
      return 0;
    }
    if (!agentConfig.getRegisteredApiConfigs()) {
      return 0;
    }
    if (!agentConfig.getRegisteredApiConfigs().length) {
      return 0;
    }
    for (let apiConfig of agentConfig.getRegisteredApiConfigs()) {
      if (
        apiConfig.getMethod() === apiBufferKey.getMethod() &&
        apiConfig.getUri().equals(apiBufferKey.getUri())
      ) {
        return apiConfig.getBufferSize();
      }
    }
    return 0;
  }
  getRegisteredApiCountToCapture(): number {
    let agentConfig: AgentConfig | null = this.getOperatingConfig();
    if (!agentConfig) {
      return 0;
    }
    if (!agentConfig.getRegisteredApiConfigs()) {
      return 0;
    }
    if (agentConfig.getRegisteredApiConfigs().length === 0) {
      return 0;
    }
    let totalApis: number = 0;
    for (let apiConfig of agentConfig.getRegisteredApiConfigs()) {
      if (apiConfig.getBufferSize()) {
        totalApis += apiConfig.getBufferSize();
      }
    }
    return totalApis;
  }
  syncForKey(key: ApiBufferKey) {
    try {
      let buffer: SimpleBuffer | undefined = this.bufferMap.getBuffer(key);
      if (!buffer) {
        return;
      }
      let iterations: number = buffer.getContentCount();
      if (iterations === 0) {
        return;
      }
      while (iterations-- > 0) {
        let apiSample: APISample | undefined = buffer.poll();
        if (!apiSample) {
          break;
        }
        postRequest(this.ctUrl + this.getUri(), [apiSample])
          .then(() => {})
          .catch((error) => {
            SDKLogger.error("While sending registered api sample: " + error);
          });
      }
    } catch (e) {
      SDKLogger.error("While syncing registered api sample: " + e);
    }
  }
}

export default RegisteredApiBufferManagerWorker;