import { GeoreferencedMap } from '@allmaps/annotation';
import { Point, Line, Size, FetchFn, Bbox, TileZoomLevel, Ring, Gcp, ImageRequest } from '@allmaps/types';
import { DistortionMeasure, TransformationType } from '@allmaps/transform';
import { Projection } from '@allmaps/project';
import { FetchableTile } from '../tilecache/FetchableTile.js';
import { CacheableTile } from '../tilecache/CacheableTile.js';
import { TileCache } from '../tilecache/TileCache.js';
import { WarpedMapList } from '../maps/WarpedMapList.js';
import { WarpedMap, WarpedMapWithImage } from '../maps/WarpedMap.js';
import { WebGL2WarpedMap } from '../webgl2.js';
import { TriangulatedWarpedMap } from '../maps/TriangulatedWarpedMap.js';

export type ShouldRenderOptions = {
    checkOpacity: boolean;
};
export type SelectionOptions = MaskOptions & {
    onlyVisible?: boolean;
    mapIds?: Iterable<string>;
    geoPoint?: Point;
    geoBbox?: Bbox;
    projectedGeoPoint?: Point;
    projectedGeoBbox?: Bbox;
};
export type MaskOptions = {
    applyMask: boolean;
};
export type ProjectionOptions = {
    projection: Projection;
};
export type TransformationOptions = {
    type: TransformationType;
    options?: unknown;
};
export type GeoreferencedMapOptions = {
    gcps: Gcp[];
    resourceMask: Ring;
    transformationType: TransformationType;
    internalProjection: Projection;
};
export type WarpedMapOptions = {
    fetchFn?: FetchFn;
    gcps: Gcp[];
    resourceMask: Ring;
    transformationType: TransformationType;
    internalProjection: Projection;
    projection: Projection;
    visible: boolean;
    anticipateVisibility: boolean;
    overviewTilesSelection: 'highest' | 'lowest';
    overviewTilesMaxResolution: number | undefined;
    applyMask: boolean;
    distortionMeasure: DistortionMeasure | undefined;
};
export type WarpedMapWithoutGeoreferencedMapOptions = Omit<WarpedMapOptions, keyof GeoreferencedMapOptions>;
export type SpecificTriangulatedWarpedMapOptions = {
    resourceResolution?: number;
    distortionMeasures: DistortionMeasure[];
};
export type TriangulatedWarpedMapOptions = SpecificTriangulatedWarpedMapOptions & WarpedMapOptions;
export type TriangulatedWarpedMapWithoutGeoreferencedMapOptions = Omit<TriangulatedWarpedMapOptions, keyof GeoreferencedMapOptions>;
export type SpecificWebGL2WarpedMapOptions = {
    renderMaps?: boolean;
    renderLines?: boolean;
    renderPoints?: boolean;
    renderGcps: boolean;
    renderGcpsColor?: string;
    renderGcpsSize?: number;
    renderGcpsBorderColor?: string;
    renderGcpsBorderSize?: number;
    renderTransformedGcps: boolean;
    renderTransformedGcpsColor?: string;
    renderTransformedGcpsSize?: number;
    renderTransformedGcpsBorderColor?: string;
    renderTransformedGcpsBorderSize?: number;
    renderVectors: boolean;
    renderVectorsColor?: string;
    renderVectorsSize?: number;
    renderVectorsBorderColor?: string;
    renderVectorsBorderSize?: number;
    renderFullMask: boolean;
    renderFullMaskColor?: string;
    renderFullMaskSize?: number;
    renderFullMaskBorderColor?: string;
    renderFullMaskBorderSize?: number;
    renderMask: boolean;
    renderMaskColor?: string;
    renderMaskSize?: number;
    renderMaskBorderColor?: string;
    renderMaskBorderSize?: number;
    renderAppliedMask: boolean;
    renderAppliedMaskColor?: string;
    renderAppliedMaskSize?: number;
    renderAppliedMaskBorderColor?: string;
    renderAppliedMaskBorderSize?: number;
    opacity: number;
    saturation: number;
    removeColor: boolean;
    removeColorColor: string;
    removeColorThreshold: number;
    removeColorHardness: number;
    colorize: boolean;
    colorizeColor: string;
    distortionColor00: string;
    distortionColor01: string;
    distortionColor1: string;
    distortionColor2: string;
    distortionColor3: string;
    renderGrid: boolean;
    renderGridColor: string;
    debugTriangles: boolean;
    debugTiles: boolean;
};
export type WebGL2WarpedMapOptions = SpecificWebGL2WarpedMapOptions & TriangulatedWarpedMapOptions;
export type WebGL2WarpedMapWithoutGeoreferencedMapOptions = Omit<WebGL2WarpedMapOptions, keyof GeoreferencedMapOptions>;
export type GetWarpedMapOptions<W extends WarpedMap> = W extends WebGL2WarpedMap ? WebGL2WarpedMapOptions : W extends TriangulatedWarpedMap ? TriangulatedWarpedMapOptions : W extends WarpedMap ? WarpedMapOptions : never;
export type SpecificWarpedMapListOptions<W extends WarpedMap> = {
    createRTree: boolean;
    rtreeUpdatedOptions: Array<keyof WebGL2WarpedMapOptions>;
    animatedOptions: Array<keyof WebGL2WarpedMapOptions>;
    projection: Projection;
    warpedMapFactory: WarpedMapFactory<W>;
};
export type WarpedMapListOptions<W extends WarpedMap> = SpecificWarpedMapListOptions<W> & Partial<WebGL2WarpedMapOptions>;
export type SpecificBaseRenderOptions<W extends WarpedMap> = {
    warpedMapList?: WarpedMapList<W>;
    anticipateInteraction: boolean;
    requestViewportBufferRatio: number;
    overviewRequestViewportBufferRatio: number;
    pruneViewportBufferRatio: number;
    overviewPruneViewportBufferRatio: number;
    scaleFactorCorrection: number;
    log2ScaleFactorCorrection: number;
    spritesMaxHigherLog2ScaleFactorDiff: number;
    spritesMaxLowerLog2ScaleFactorDiff: number;
    maxTotalOverviewResolutionRatio: number;
    maxGcpsExactTpsToResource: number;
};
export type BaseRenderOptions<W extends WarpedMap> = SpecificBaseRenderOptions<W> & Partial<WarpedMapListOptions<W>>;
export type SpecificWebGL2RenderOptions = {
    warpedMapFactory: WarpedMapFactory<WebGL2WarpedMap>;
};
export type WebGL2RenderOptions = SpecificWebGL2RenderOptions & BaseRenderOptions<WebGL2WarpedMap>;
export type CanvasRenderOptions = BaseRenderOptions<WarpedMap>;
export type IntArrayRenderOptions = BaseRenderOptions<WarpedMap>;
export type TileCacheOptions<D> = {
    fetchFn: FetchFn;
    tileCacheForSprites: TileCache<D>;
};
export type AnimationOptions = {
    animate: boolean;
    animatedOptions?: Array<keyof WebGL2WarpedMapOptions>;
    duration: number;
};
export type AnimationInternalOptions = {
    stage: AnimationStage;
    optionKeysPossiblyChanged?: string[];
    optionKeysToOmit?: string[];
};
export type AnimationStage = 'init' | 'pre' | 'animate';
export type Renderer = {
    render: (...params: any[]) => any;
};
export type GetImageData<D> = (data: Uint8ClampedArray) => D;
export type GetImageDataValue<D> = (data: D, index: number) => number;
export type GetImageDataSize<D> = (data: D) => Size;
export type WarpedMapFactory<W extends WarpedMap> = (mapId: string, georeferencedMap: GeoreferencedMap, listOptions?: Partial<WarpedMapListOptions<W>>, mapOptions?: Partial<GetWarpedMapOptions<W>>) => W;
export type CacheableTileFactory<D> = (fetchableTile: FetchableTile, fetchFn?: FetchFn) => CacheableTile<D>;
export type FetchableTileOptions = {
    imageRequest: ImageRequest;
    spritesInfo: SpritesInfo;
    warpedMapsByResourceId: Map<string, WarpedMapWithImage[]>;
};
export type SpritesInfo = {
    sprites: Sprite[];
    imageUrl: string;
    imageSize: Size;
};
export type Sprite = {
    imageId: string;
    scaleFactor: number;
    x: number;
    y: number;
    width: number;
    height: number;
    spriteTileScale?: number;
};
export type RenderLineGroupOptions = {
    viewportSize: number;
    color: string;
    viewportBorderSize: number;
    borderColor: string;
};
export type RenderPointGroupOptions = {
    viewportSize: number;
    color: string;
    viewportBorderSize: number;
    borderColor: string;
};
export type LineGroup = {
    projectedGeoLines: Line[];
    projectedGeoPreviousLines?: Line[];
} & Partial<RenderLineGroupOptions>;
export type PointGroup = {
    projectedGeoPoints: Point[];
    projectedGeoPreviousPoints?: Point[];
} & Partial<RenderPointGroupOptions>;
export type MapPruneInfo = {
    tileZoomLevelForViewport?: TileZoomLevel;
    overviewTileZoomLevelForViewport?: TileZoomLevel;
    resourceViewportRingBboxForViewport?: Bbox;
};
export type MapPruneConstants = {
    maxHigherLog2ScaleFactorDiff: number;
    maxLowerLog2ScaleFactorDiff: number;
};