import { TemplateOptionsReader } from "./enums.js";
import {
  AtlasOptions,
  AtlasShapeResponse,
  BaseRequest,
  Boundaries,
  Geometry,
  JsonProperties,
  LineString,
  MapShapeResponse,
  MultiLineString,
  MultiPoint,
  MultiPolygon,
  OptionsType,
  Point,
  Polygon,
  TemplateColorValue,
  TemplateHeaderValue,
  TemplateNumberValue,
  ShapeResponse,
  ApiEntity,
  CentroidResponse,
  MapCentroidResponse,
  AtlasCentroidResponse,
  GeoJsonFeature,
  GeometryCollection,
  GeometryType,
  BaseSearchRequest,
} from "./types/index.js";
import { getObjectValue } from "./utils/index.js";

export function isExtent<T>(val: Boundaries | T): val is Boundaries {
  return (
    val instanceof Object &&
    typeof val.top === "number" &&
    typeof val.right === "number" &&
    typeof val.bottom === "number" &&
    typeof val.left === "number"
  );
}

export function isGeometryCollection(
  val: GeoJsonFeature["geometry"]
): val is GeometryCollection {
  return val.type === GeometryType.GeometryCollection;
}

export function isPoint(val: Geometry): val is Point {
  return val.type === GeometryType.Point;
}

export function isMultiPoint(val: Geometry): val is MultiPoint {
  return val.type === GeometryType.MultiPoint;
}

export function isLineString(val: Geometry): val is LineString {
  return val.type === GeometryType.LineString;
}

export function isMultiLineString(val: Geometry): val is MultiLineString {
  return val.type === GeometryType.MultiLineString;
}

export function isPolygon(val: Geometry): val is Polygon {
  return val.type === GeometryType.Polygon;
}

export function isMultiPolygon(val: Geometry): val is MultiPolygon {
  return val.type === GeometryType.MultiPolygon;
}

export function isMapShapeResponse(
  val?: ShapeResponse
): val is MapShapeResponse {
  if (!val) return false;
  for (const i in val) {
    const shapes = val[i][1];
    for (const i in shapes) {
      const val = shapes[i];
      if (val instanceof Array) return false;
    }
  }

  return true;
}

export function isAtlasShapeResponse(
  val?: ShapeResponse
): val is AtlasShapeResponse {
  if (!val) return false;
  for (const i in val) {
    const shapes = val[i][1];
    for (const i in shapes) {
      const val = shapes[i];
      if (typeof val === "string") return false;
    }
  }

  return true;
}

export function isMapCentroidResponse(
  val?: CentroidResponse
): val is MapCentroidResponse {
  if (!val) return false;
  const values = val as MapCentroidResponse;
  try {
    for (const i in values) {
      if (!values[i].centroid) throw new Error("invalid centroid");
    }
    return true;
  } catch (e) {
    return false;
  }
}

export function isAtlasCentroidResponse(
  val?: CentroidResponse
): val is AtlasCentroidResponse {
  if (!val) return false;
  const values = val as AtlasCentroidResponse;
  try {
    for (const i in values) {
      for (const k in values[i]) {
        if (!values[i][k].centroid) throw new Error("invalid centroid");
      }
    }
    return true;
  } catch (e) {
    return false;
  }
}

export function isValidOption<T extends Partial<OptionsType>>(
  options: OptionsType | T
): options is T {
  if (!(options instanceof Object)) return false;
  return (
    Object.prototype.hasOwnProperty.call(options, "serverUrl") &&
    Object.prototype.hasOwnProperty.call(options, "token")
  );
}

export function isValidBaseOption<T extends Partial<OptionsType>>(
  options: T | BaseRequest
): options is BaseRequest {
  return isValidOption<T>(options);
}

export function isValidSearchPinOption(
  options: OptionsType
): options is BaseSearchRequest {
  if (!(options instanceof Object)) return false;
  if (!isValidBaseOption<BaseSearchRequest>(options)) return false;
  return (
    Object.prototype.hasOwnProperty.call(options, "search") ||
    Object.prototype.hasOwnProperty.call(options, "pin")
  );
}

export function isValidAtlasOption(
  options: OptionsType | AtlasOptions
): options is AtlasOptions {
  if (!isValidBaseOption<AtlasOptions>(options)) return false;
  return !!options[ApiEntity.Atlas];
}

export function isJsonProperties<T = never>(
  val: unknown
): val is JsonProperties<T> {
  if (!(val instanceof Object)) return false;
  let valid = true;
  const keys = Object.keys(val);
  const values = Object.values(val);
  for (const i in keys) {
    const value = values[i];
    if (
      !["string", "number", "undefined", "object", "boolean"].includes(
        typeof value
      )
    ) {
      valid = false;
    } else if (value instanceof Object) valid = isJsonProperties<T>(value);
    if (!valid) break;
  }

  return true;
}

export function isTemplateOption(
  val: unknown | ReturnType<typeof TemplateOptionsReader.value>
): val is ReturnType<typeof TemplateOptionsReader.value> {
  let ret = false;
  for (const key of TemplateOptionsReader.values()) {
    if (key === val) {
      ret = true;
      break;
    }
  }
  return ret;
}

export function isTemplateValue(
  val: unknown | TemplateHeaderValue
): val is TemplateHeaderValue {
  return typeof getObjectValue(val, "header") === "string";
}

export function isTemplateNumberValue(
  val: unknown | TemplateNumberValue
): val is TemplateNumberValue {
  if (!isTemplateValue(val)) return false;
  return (
    ["string", "undefined"].includes(typeof getObjectValue(val, "min")) &&
    ["string", "undefined"].includes(typeof getObjectValue(val, "max"))
  );
}

export function isTemplateColorValue(
  val: unknown | TemplateColorValue
): val is TemplateColorValue {
  if (!isTemplateNumberValue(val)) return false;
  const colors = getObjectValue(val, "colors");
  if (!(colors instanceof Array)) return false;
  return !colors.find((item) => typeof item !== "string");
}