import {
  BaseRequest,
  ViewBoxOptions,
  StylesOptions,
  AsOptions,
  OptionsType,
  AtlasValues,
  StyleFeaturesListSchema,
  AtlasOptions,
  IdKeyType,
  ApiEntity,
  LabelProperty,
  ShapeProperty,
  BaseQueryString,
  SearchQueryString,
  ViewBoxQueryString,
  StyleQueryString,
  ParmasEntity,
  BaseSearchPinRequest,
} from "../types/index.js";
import {
  isValidAtlasOption,
  isValidBaseOption,
  isValidOption,
  isValidSearchPinOption,
} from "../guardians.js";
import { getLabelsString, getStyleFeatureString } from "../utils/options.js";

export function getBaseOptions<T extends BaseRequest>(args: T) {
  const { token, cacheControl } = args;
  const options: AsOptions<BaseRequest> = {};

  token && Object.assign(options, { [BaseQueryString.Token]: token });

  cacheControl &&
    Object.assign(options, {
      [BaseQueryString.CacheControl]: cacheControl,
    });

  return options;
}

export function getSearchPinOptions<T extends BaseSearchPinRequest>(args: T) {
  const { search, pin } = args;
  const options: AsOptions<
    Pick<BaseSearchPinRequest, ApiEntity.Search | ApiEntity.Pin>
  > = {};

  search?.q &&
    Object.assign(options, { [SearchQueryString.Q]: search.q.join(";") });

  search?.qa &&
    Object.assign(options, { [SearchQueryString.QA]: search.qa.join(";") });

  search?.qp &&
    Object.assign(options, { [SearchQueryString.QP]: search.qp.join(";") });

  search?.f &&
    Object.assign(options, { [SearchQueryString.F]: search.f.join(";") });

  search?.skip &&
    Object.assign(options, { [SearchQueryString.Skip]: search.skip });

  search?.limit &&
    Object.assign(options, { [SearchQueryString.Limit]: search.limit });

  pin?.coords &&
    Object.assign(options, { [SearchQueryString.Pin]: pin.coords.join(";") });

  options.pin &&
    pin?.radius &&
    Object.assign(options, {
      [SearchQueryString.Pin]: `${options[SearchQueryString.Pin]};${
        pin.radius
      };${pin.projection}`,
    });
  return options;
}

export function getViewBoxOptions<T extends ViewBoxOptions>(args: T) {
  const { margin, area, projection, point, group } = args;

  const options: AsOptions<ViewBoxOptions> = {};

  projection &&
    Object.assign(options, { [ViewBoxQueryString.Projection]: projection });

  point &&
    Object.assign(options, { [ViewBoxQueryString.Point]: point.join(";") });

  area && Object.assign(options, { [ViewBoxQueryString.Area]: area });

  group && Object.assign(options, { [ViewBoxQueryString.Group]: group });

  margin &&
    Object.assign(options, {
      [ViewBoxQueryString.Margin]: `${margin.top};${margin.right};${margin.bottom};${margin.left}`,
    });

  return options;
}

export function getStyleOptions<T extends StylesOptions>(args: T) {
  const {
    [IdKeyType.Style]: styleId,
    [ParmasEntity.DefaultStyle]: defaultStyle = {},
    [ParmasEntity.FeatureStyle]: featureStyle,
    [ParmasEntity.Labels]: labels,
    [ParmasEntity.BgColor]: bgColor,
    [ParmasEntity.Alpha]: alpha,
  } = args;

  const options: AsOptions<StylesOptions> = {};

  labels &&
    Object.assign(options, {
      [StyleQueryString.Labels]: getLabelsString(labels),
    });

  styleId &&
    Object.assign(options, {
      [StyleQueryString.StyleId]: styleId,
    });

  bgColor &&
    Object.assign(options, {
      [StyleQueryString.BgColor]: bgColor,
    });

  alpha &&
    Object.assign(options, {
      [StyleQueryString.Alpha]: alpha,
    });

  featureStyle &&
    Object.assign(options, {
      [StyleQueryString.FeatureStyle]: getFeatureStyleOptions(featureStyle),
    });

  defaultStyle[ShapeProperty.Fill] &&
    Object.assign(options, {
      [StyleQueryString.Fill]: defaultStyle[ShapeProperty.Fill],
    });

  defaultStyle[ShapeProperty.Stroke] &&
    Object.assign(options, {
      [StyleQueryString.Stroke]: defaultStyle[ShapeProperty.Stroke],
    });

  defaultStyle[ShapeProperty.StrokeWidth] !== undefined &&
    !isNaN(defaultStyle[ShapeProperty.StrokeWidth]) &&
    Object.assign(options, {
      [StyleQueryString.StrokeWidth]: defaultStyle[ShapeProperty.StrokeWidth],
    });

  defaultStyle[ShapeProperty.PointRadius] !== undefined &&
    !isNaN(defaultStyle[ShapeProperty.PointRadius]) &&
    Object.assign(options, {
      [StyleQueryString.PointRadius]: defaultStyle[ShapeProperty.PointRadius],
    });

  defaultStyle[LabelProperty.LabelFont] &&
    Object.assign(options, {
      [StyleQueryString.LabelFont]: defaultStyle[LabelProperty.LabelFont],
    });

  defaultStyle[LabelProperty.LabelFontStyle] &&
    Object.assign(options, {
      [StyleQueryString.LabelFontStyle]:
        defaultStyle[LabelProperty.LabelFontStyle],
    });

  defaultStyle[LabelProperty.LabelColor] &&
    Object.assign(options, {
      [StyleQueryString.LabelColor]: defaultStyle[LabelProperty.LabelColor],
    });

  defaultStyle[LabelProperty.LabelSize] !== undefined &&
    !isNaN(defaultStyle[LabelProperty.LabelSize]) &&
    Object.assign(options, {
      [StyleQueryString.LabelSize]: defaultStyle[LabelProperty.LabelSize],
    });

  defaultStyle[LabelProperty.LabelWeight] !== undefined &&
    !isNaN(defaultStyle[LabelProperty.LabelWeight]) &&
    Object.assign(options, {
      [StyleQueryString.LabelWeight]: defaultStyle[LabelProperty.LabelWeight],
    });

  defaultStyle[LabelProperty.LabelStroke] &&
    Object.assign(options, {
      [StyleQueryString.LabelStroke]: defaultStyle[LabelProperty.LabelStroke],
    });

  defaultStyle[LabelProperty.LabelStrokeWidth] &&
    Object.assign(options, {
      [StyleQueryString.LabelStrokeWidth]:
        defaultStyle[LabelProperty.LabelStrokeWidth],
    });

  return options;
}

export function getAtlasMapsOption(atlasMaps: AtlasValues["maps"]) {
  return atlasMaps
    .map((item) => {
      const { removePrevious = [] } = item;
      const removePreiovusString = removePrevious.length
        ? `;${removePrevious.join(";")}`
        : "";
      return `${item[IdKeyType.Map]};${
        item.precision || ""
      }${removePreiovusString}`;
    })
    .join("|");
}

export function getFeatureStyleOptions(featureStyle: StyleFeaturesListSchema) {
  return Object.keys(featureStyle)
    .map((featureId) => {
      return getStyleFeatureString({
        [IdKeyType.Feature]: featureId,
        style: featureStyle[featureId],
      });
    })
    .join("|");
}

export function getAtlasOptions<T extends AtlasOptions>(args: T) {
  const { [ApiEntity.Atlas]: atlas } = args;
  const options: AsOptions<AtlasOptions> = {};
  if (!atlas) return options;
  const precision = atlas.defaultPrecision || "0";
  const maps = getAtlasMapsOption(atlas.maps);
  Object.assign(options, {
    precision,
    atlas: maps,
  });

  return options;
}

export function getRequestOptions<T extends OptionsType>(args: T) {
  const baseOptions = isValidBaseOption(args) && getBaseOptions(args);
  const searchPinOptions =
    isValidSearchPinOption(args) && getSearchPinOptions(args);
  const viewBoxOptions =
    isValidOption<ViewBoxOptions>(args) && getViewBoxOptions(args);
  const styleOptions =
    isValidOption<StylesOptions>(args) && getStyleOptions(args);
  const atlasOptions = isValidAtlasOption(args) && getAtlasOptions(args);
  const options: AsOptions<OptionsType> = {
    ...baseOptions,
    ...searchPinOptions,
    ...viewBoxOptions,
    ...styleOptions,
    ...atlasOptions,
  };
  return options;
}