import AgentConfig from "../common/data/AgentConfig";
import ApiProcessor from "./ApiProcessor";
import ConfigManager from "../config/ConfigManager";
import configManager from "../config/ConfigManager";
import ConfigUpdateListener from "../config/ConfigUpdateListener";
import ObservedApi from "../common/data/ObservedApi";
import ApiConfig from "../common/data/ApiConfig";
import HttpRequest from "./HttpRequest";
import { HttpRequestMethod } from "../common/constant/ShortloopCommonConstant";
import RequestResponseContext from "./RequestResponseContext";
import ApiBufferKey from "../buffer/ApiBufferKey";
import SDKLogger from "../SDKLogger";
import BlackListRule from "../common/data/BlackListRule";

class ShortloopNodeFilter implements ConfigUpdateListener {
  private agentConfig: AgentConfig | undefined;
  private configManager: ConfigManager;
  private apiProcessor: ApiProcessor;
  private readonly userApplicationName: string;
  constructor(
    configManager: configManager,
    apiProcessor: ApiProcessor,
    userApplicationName: string
  ) {
    this.configManager = configManager;
    this.apiProcessor = apiProcessor;
    this.userApplicationName = userApplicationName;
  }

  public getApiProcessor(): ApiProcessor {
    return this.apiProcessor;
  }

  public init(): boolean {
    this.configManager.subscribeToUpdates(this);
    return true;
  }

  onErroneousConfigUpdate(): void {
    this.agentConfig = AgentConfig.noOpAgentConfig;
  }

  onSuccessfulConfigUpdate(agentConfig: AgentConfig): void {
    this.agentConfig = agentConfig;
  }

  private getApiConfig(
    observedApi: ObservedApi,
    agentConfig: AgentConfig
  ): ApiConfig | null {
    if (agentConfig?.getRegisteredApiConfigs()?.length === 0) {
      return null;
    }
    if (!this.agentConfig) return null;
    let registeredApis: ApiConfig[] =
      this.agentConfig.getRegisteredApiConfigs();
    for (let i = 0; i < registeredApis.length; i++) {
      if (observedApi.matches(registeredApis[i])) {
        return registeredApis[i];
      }
    }
    return null;
  }

  private getObservedApiFromRequest(request: HttpRequest): ObservedApi {
    let method: HttpRequestMethod = request.getMethod() as HttpRequestMethod;
    return new ObservedApi(request.getRawUri(), method);
  }

  public processReqAndRes(req: any, res: any, next: Function) {
    // let agentConfigLocal: AgentConfig | undefined = this.agentConfig;
    // if (!agentConfigLocal) {
    //   next();
    //   return;
    // }
    // if (agentConfigLocal?.getCaptureApiSample() === false) {
    //   next();
    //   return;
    // }
    let queryParams: any = null;

    if (req.query) {
      queryParams = { ...req.query };
    }

    if (queryParams && Object.keys(queryParams).length > 0) {
      for (let key in queryParams) {
        if (!Array.isArray(queryParams[key])) {
          queryParams[key] = [queryParams[key]];
        }
      }
    }

    let request: HttpRequest = new HttpRequest(
      req.path,
      req.hostname,
      req.socket.address()?.port,
      req.protocol,
      req.method,
      req.headers,
      queryParams,
      null
    );

    let observedApi: ObservedApi = this.getObservedApiFromRequest(request);
    // if (this.isBlackListedApi(observedApi, agentConfigLocal)) {
    //   next();
    //   return;
    // }

    let context: RequestResponseContext = new RequestResponseContext(
      request,
      this.userApplicationName
    );
    context.setObservedApi(observedApi);
    // let apiConfig: ApiConfig | null = this.getApiConfig(
    //   observedApi,
    //   agentConfigLocal
    // );
    // context.setAgentConfig(agentConfigLocal);
    
    context.setApiBufferKey(ApiBufferKey.getApiBufferKeyFromObservedApi(observedApi));
    this.apiProcessor.processRegisteredApi(context, req, res, next);


    // if (apiConfig) {
    //   context.setApiConfig(apiConfig);
    //   context.setApiBufferKey(
    //     ApiBufferKey.getApiBufferKeyFromApiConfig(apiConfig)
    //   );
    //   this.apiProcessor.processRegisteredApi(context, req, res, next);
    // } else {
    //   context.setApiBufferKey(
    //     ApiBufferKey.getApiBufferKeyFromObservedApi(observedApi)
    //   );
    //   this.apiProcessor.processDiscoveredApi(context, res, next);
    // }
  }

  private isBlackListedApi(
    observedApi: ObservedApi,
    agentConfig: AgentConfig
  ): boolean {
    try {
      if (!agentConfig || !agentConfig.getBlackListRules()) {
        return false;
      }
      let blackListRules: BlackListRule[] = agentConfig.getBlackListRules();
      for (let i = 0; i < blackListRules.length; i++) {
        if (
          blackListRules[i].matchesUri(
            observedApi.getUri(),
            observedApi.getMethod()
          )
        ) {
          return true;
        }
      }
    } catch (e) {
      SDKLogger.error("Error ShortloopSpringFilter::isBlackListedApi" + e);
    }
    return false;
  }
}

export default ShortloopNodeFilter;