import {
  BrandSafetySeverity,
  CategoryRating,
  CategoryProviderValue,
  ICategoryProvider,
  ICategoryValue,
  FraudSeverity,
} from "../categories/categoryProvider";
import { CategoryRequest } from "../services/category.service";

export default class MockCategoryProvider implements ICategoryProvider {
  decode(value: string): ICategoryValue {
    return new MockCategoryValue(value);
  }
  isRequestValid(categoryRequest: CategoryRequest): boolean {
    if (
      !categoryRequest.device &&
      categoryRequest.urlOrBundle &&
      categoryRequest.urlOrBundle.length > 0
    ) {
      return true;
    }
    if (categoryRequest.device && categoryRequest.ip && categoryRequest.ip.length > 0) {
      return true;
    }
    return false;
  }
  async getCategories(categoryRequest: CategoryRequest): Promise<CategoryProviderValue> {
    if (categoryRequest.device) {
      const expireTime: number = 10000;
      const refreshTime: number = Date.now() + 5000;
      return { encodedValue: categoryRequest.ip + "|" + refreshTime, ttl: expireTime };
    } else if (categoryRequest.requestSource.environmentType === "web") {
      const sp: URLSearchParams = new URLSearchParams(
        categoryRequest.urlOrBundle!.substring(categoryRequest.urlOrBundle!.indexOf("?"))
      );
      const refresh = sp.get("refreshTime");
      const expire = sp.get("expire");
      const now: number = Date.now();
      let refreshTime: number = now + 5000;
      let expireTime: number = 10000;
      if (refresh != null) {
        refreshTime = parseInt(refresh);
      }
      if (expire != null) {
        expireTime = parseInt(expire);
      }
      const value = sp.get("status") + "|" + refreshTime;
      return { encodedValue: value, ttl: expireTime };
    } else {
      const elt = categoryRequest?.urlOrBundle!.split(".");
      const now: number = Date.now();
      const refreshTime: number = now + 5000;
      const expireTime: number = 10000;
      const value = elt[1] + "|" + refreshTime;
      return { encodedValue: value, ttl: expireTime };
    }
  }
  needUserAgent(): boolean {
    return false;
  }
}
export class MockCategoryValue implements ICategoryValue {
  private segments: string[] = [
    CategoryRating.Unknown,
    CategoryRating.Unknown,
    CategoryRating.Unknown,
  ];
  private refreshTTL: number;
  private brandSafetyResult = new Map<BrandSafetySeverity, CategoryRating>();
  private fraudResult = new Map<FraudSeverity, CategoryRating>();
  private deviceFraud: CategoryRating = CategoryRating.Unknown;
  constructor(value: string) {
    const splits = value.split("|");
    this.refreshTTL = parseInt(splits[1]);
    if (!this.checkIP(splits[0])) {
      this.segments = splits[0].split(":");
      let bsValue = CategoryRating.Unknown;
      if (this.segments.length > 0) {
        bsValue = this.parseValue(this.segments[0]);
      }
      this.brandSafetyResult.set(BrandSafetySeverity.High, bsValue);
      this.fraudResult.set(FraudSeverity.High, bsValue);
      if (this.segments.length > 1) {
        bsValue = this.parseValue(this.segments[1]);
      }
      this.fraudResult.set(FraudSeverity.Medium, bsValue);
      this.brandSafetyResult.set(BrandSafetySeverity.Medium, bsValue);
      if (this.segments.length > 2) {
        bsValue = this.parseValue(this.segments[2]);
      }
      this.brandSafetyResult.set(BrandSafetySeverity.Low, bsValue);
    }
  }

  private checkIP(value: string): boolean {
    const bytes = value.split(".");
    if (bytes.length === 4) {
      switch (bytes[3]) {
        case "1":
          this.deviceFraud = CategoryRating.Safe;
          break;
        case "2":
          this.deviceFraud = CategoryRating.Unsafe;
          break;
        default:
          this.deviceFraud = CategoryRating.Unknown;
      }
      return true;
    }
    return false;
  }
  private parseValue(text: string): CategoryRating {
    let bsValue: CategoryRating = CategoryRating.Safe;
    if (text.includes("unsafe")) {
      bsValue = CategoryRating.Unsafe;
    } else if (text.includes("unknown")) {
      bsValue = CategoryRating.Unknown;
    }
    return bsValue;
  }
  getDeviceFraud(): CategoryRating {
    return this.deviceFraud;
  }
  getBrandSafety(severity: BrandSafetySeverity): CategoryRating {
    return this.brandSafetyResult.get(severity)!;
  }
  getPublisherFraud(severity: FraudSeverity): CategoryRating {
    return this.fraudResult.get(severity)!;
  }

  getRefreshTTL(): number {
    return this.refreshTTL;
  }
  toSegmentList(): string[] {
    return this.segments;
  }
  isBlockedBySegment(stringSegment: string): boolean {
    return this.segments.includes(stringSegment);
  }
  isBrandSuitable(stringSegment: string, _passUnknown: boolean): boolean {
    return !this.isBlockedBySegment(stringSegment);
  }
}