declare module "@inovitas/infra3dapi";

declare type Fn = (arg: any) => void;
declare class EventEmitter {
  protected _events: {
    [eventType: string]: Fn[];
  };
  constructor();
  on(eventType: string, fn: Fn): void;
  off(eventType: string, fn: Fn): void;
  fire(eventType: string, data: unknown): void;
  private _listens;
}

declare type ViewerEventType =
  | "nodechanged"
  | "panorotationchanged"
  | "campaignschanged"
  | "lookazimuthchanged";

interface IViewer {
  fire<T>(type: ViewerEventType, event: T): void;
  off<T>(type: ViewerEventType, handler: (event: T) => void): void;
  on<T>(type: ViewerEventType, handler: (event: T) => void): void;
}

interface ViewerEvent {
  target: IViewer;
  type: ViewerEventType;
}

interface NodechangedEvent extends ViewerEvent {
  lat: number;
  lon: number;
  height: number;
  campaign_id: string;
  date: string;
  type: "nodechanged";
}

interface CampaignschangedEvent extends ViewerEvent {
  id: number;

  project: number;

  description: string;

  type: "campaignschanged";
}

interface PanorotationchangedEvent extends ViewerEvent {
  fov: number;

  lat: number;

  lon: number;

  type: "panorotationchanged";
}

interface LookazimuthchangedEvent extends ViewerEvent {
  value: number;

  type: "lookazimuthchanged";
}

interface ICampaign {
  uid: string;
  name: string;
  type: string;
  start_timestamp: number;
  end_timestamp: number;
}

interface IBaseFeatureStyle {
  stylename: string;
  rules: IBaseFeatureStyleRule[];
}
interface IBaseFeatureStyleRule {
  name?: string;
  filter?: string;
  symbolizer: "point" | "line" | "polygon";
  params: IBaseFeatureStyleParams;
}
interface IBaseFeatureStyleParams {
  stroke?: number[];
}
interface IPointFeatureStyle extends IBaseFeatureStyle {
  rules: IPointFeatureStyleRule[];
}
interface IPointFeatureStyleRule extends IBaseFeatureStyleRule {
  symbolizer: "point";
  params:
    | INamedFontMarkerFeatureStyleParams
    | ICustomFontMarkerFeatureStyleParams
    | IBillboardFeatureStyleParams
    | IPointFeatureStyleParams;
}
interface IPointFeatureStyleParams extends IBaseFeatureStyleParams {
  size?: number;
  "vertex-colors"?: boolean;
}
interface INamedFontMarkerFeatureStyleParams extends IPointFeatureStyleParams {
  "font-marker": {
    name:
      | "square-o"
      | "square"
      | "location-arrow"
      | "star-o"
      | "star"
      | "map-pin"
      | "map-marker"
      | "crosshairs"
      | "circle-o"
      | "circle"
      | "cross";
    rotation?: number;
    fontsize?: number;
    anchor?: [string, string];
  };
}
interface ICustomFontMarkerFeatureStyleParams extends IPointFeatureStyleParams {
  "font-marker": {
    fontface: string;
    content: string;
    rotation?: number;
    fontsize?: number;
    anchor?: [string, string];
  };
}
interface IBillboardFeatureStyleParams extends IPointFeatureStyleParams {
  billboard: string;
}
interface ILineFeatureStyle extends IBaseFeatureStyle {
  rules: (ILineFeatureStyleRule | IPointFeatureStyleRule)[];
}
interface ILineFeatureStyleRule extends IBaseFeatureStyleRule {
  symbolizer: "line";
  params: ILineFeatureStyleParams;
}
interface ILineFeatureStyleParams extends IBaseFeatureStyleParams {
  "stroke-width": number;
  "stroke-dash-width"?: number;
  "stroke-gap-width"?: number;
}
interface IPolygonFeatureStyle extends IBaseFeatureStyle {
  rules: (
    | IPolygonFeatureStyleRule
    | ILineFeatureStyleRule
    | IPointFeatureStyleRule
  )[];
}
interface IPolygonFeatureStyleRule extends IBaseFeatureStyleRule {
  symbolizer: "polygon";
  params: IPolygonFeatureStyleParams;
}
interface IPolygonFeatureStyleParams extends IBaseFeatureStyleParams {
  fill: number[];
  "stroke-width"?: number;
  "stroke-dash-width"?: number;
  "stroke-gap-width"?: number;
}
declare type IFeatureStyle =
  | IPolygonFeatureStyle
  | ILineFeatureStyle
  | IPointFeatureStyle;
declare type IFeatureStyleRule =
  | IPointFeatureStyleRule
  | ILineFeatureStyleRule
  | IPolygonFeatureStyleRule;
declare type IFeatureStyleParams =
  | IPointFeatureStyleParams
  | INamedFontMarkerFeatureStyleParams
  | ICustomFontMarkerFeatureStyleParams
  | IBillboardFeatureStyleParams
  | ILineFeatureStyleParams
  | IPolygonFeatureStyleParams;

interface IGeometryOverlayOptions {
  style?: IFeatureStyle;

  highlightstyle?: IFeatureStyle;

  snappable?: boolean;

  visible?: boolean;
}

declare class GeometryOverlay {
  constructor(viewer: Viewer, options?: IGeometryOverlayOptions);

  setStyle(style: IFeatureStyle): void;

  setHighlightStyle(highlightstyle: IFeatureStyle): void;

  getSnappable(): boolean;

  setSnappable(snappable: boolean): void;

  getVisible(): boolean;

  setVisible(visible: boolean): void;

  addGeometry(geometry: Geometry, selected?: boolean): void;

  removeGeometry(geometry: Geometry): void;

  clear(): void;

  selectGeometry(geometry: Geometry): void;

  unselectGeometry(geometry: Geometry): void;
}

interface IPointTo {
  type: "pano" | "panzoom" | "coordinate";
}
interface ILatLonFov extends IPointTo {
  type: "pano";
  lat: number;
  lon: number;
  fov: number;
}
interface IPanZoom extends IPointTo {
  type: "panzoom";
  panX?: number;
  panY?: number;
  zoom?: number;
}

type GeoJsonGeometryTypes = Geometry["type"];

type GeoJsonTypes = GeoJSON["type"];

type BBox =
  | [number, number, number, number]
  | [number, number, number, number, number, number];

type Position = number[]; // [number, number] | [number, number, number];

interface GeoJsonObject {
  // Don't include foreign members directly into this type def.
  // in order to preserve type safety.
  // [key: string]: any;
  type: GeoJsonTypes;
  bbox?: BBox | undefined;
}

type GeoJSON = Geometry | Feature | FeatureCollection;

type Geometry =
  | Point
  | MultiPoint
  | LineString
  | MultiLineString
  | Polygon
  | MultiPolygon
  | GeometryCollection;
type GeometryObject = Geometry;

interface Point extends GeoJsonObject {
  type: "Point";
  coordinates: Position;
}

interface MultiPoint extends GeoJsonObject {
  type: "MultiPoint";
  coordinates: Position[];
}

interface LineString extends GeoJsonObject {
  type: "LineString";
  coordinates: Position[];
}

interface MultiLineString extends GeoJsonObject {
  type: "MultiLineString";
  coordinates: Position[][];
}

interface Polygon extends GeoJsonObject {
  type: "Polygon";
  coordinates: Position[][];
}

interface MultiPolygon extends GeoJsonObject {
  type: "MultiPolygon";
  coordinates: Position[][][];
}

interface GeometryCollection<
  G extends Geometry = Geometry,
> extends GeoJsonObject {
  type: "GeometryCollection";
  geometries: G[];
}

type GeoJsonProperties = { [name: string]: any } | null;

interface Feature<
  G extends Geometry | null = Geometry,
  P = GeoJsonProperties,
> extends GeoJsonObject {
  type: "Feature";
  geometry: G;
  id?: string | number | undefined;
  properties: P;
}

interface FeatureCollection<
  G extends Geometry | null = Geometry,
  P = GeoJsonProperties,
> extends GeoJsonObject {
  type: "FeatureCollection";
  features: Array<Feature<G, P>>;
}

declare class InternalViewer {}
declare class ApmBase {}

declare class Viewer extends EventEmitter implements IViewer {
  private _sdk_viewer;
  constructor(sdk_viewer: InternalViewer);

  moveToCampaign(campaignID: string): Promise<void>;

  moveToPosition(
    easting: number,
    northing: number,
    height?: number,
    maxdist?: number,
    epsg?: number
  ): Promise<void>;

  lookAtPosition(
    easting: number,
    northing: number,
    height?: number,
    maxdist?: number,
    epsg?: number
  ): Promise<void>;

  getRoutes(simplify?: number): Promise<GeoJSON>;

  public getRouteLines(
    loa: number,
    bbox: {
      minEasting: number;
      maxEasting: number;
      minNorthing: number;
      maxNorthing: number;
      epsg?: number;
    }
  ): Promise<GeoJSON>;

  public getRouteHexes(
    loa: number,
    bbox: {
      minEasting: number;
      maxEasting: number;
      minNorthing: number;
      maxNorthing: number;
      epsg?: number;
    }
  ): Promise<GeoJSON>;

  getAllCampaigns(bbox?: {
    minEasting: number;
    maxEasting: number;
    minNorthing: number;
    maxNorthing: number;
    epsg: number;
  }): Promise<ICampaign[]>;

  getCampaign(campagin_uid: string): Promise<ICampaign>;

  attachToMeasurementTool(
    toolname: "lengthMeasure" | "areaMeasure",
    onmeasured: (value: number, geometry: number[][]) => void
  ): void;
  attachToMeasurementTool(
    toolname: "pointMeasure",
    onmeasured: (value: undefined, geometry: number[]) => void
  ): void;
  private _processMeasurementResult;

  public drawGeometry(
    geometryType: "Point" | "MultiPoint" | "LineString" | "Polygon",
    options?: {
      onDrawProgress?: (geometry: Geometry) => void;
      style?: IFeatureStyle;
      signal?: AbortSignal;
    }
  ): Promise<Geometry>;

  public addGeometryOverlay(options?: IGeometryOverlayOptions): GeometryOverlay;

  public removeGeometryOverlay(geometryoverlay: GeometryOverlay): void;

  public pickGeometry(
    signal?: AbortSignal
  ): Promise<[GeometryOverlay, Geometry]>;

  public editGeometry(
    onEditProgress: (geom: Geometry) => void,
    signal?: AbortSignal
  ): Promise<[GeometryOverlay, Geometry]>;

  public destroy(): void;

  public setUserInteraction(pan: boolean, zoom: boolean): void;

  public getCameraView(): ILatLonFov | IPanZoom;

  public setCameraView(cameraView: ILatLonFov | IPanZoom): void;

  public getCurrentNode(): Node;

  off(type: "nodechanged", handler: (event: NodechangedEvent) => void): void;
  off(
    type: "campaignschanged",
    handler: (event: CampaignschangedEvent) => void
  ): void;
  off(
    type: "panorotationchanged",
    handler: (event: PanorotationchangedEvent) => void
  ): void;
  off(
    type: "lookazimuthchanged",
    handler: (event: LookazimuthchangedEvent) => void
  ): void;
  on(type: "nodechanged", handler: (event: NodechangedEvent) => void): void;
  on(
    type: "campaignschanged",
    handler: (event: CampaignschangedEvent) => void
  ): void;
  on(
    type: "panorotationchanged",
    handler: (event: PanorotationchangedEvent) => void
  ): void;
  on(
    type: "lookazimuthchanged",
    handler: (event: LookazimuthchangedEvent) => void
  ): void;
}

declare type applicationProps = {
  name: string;
  url: string;
};
declare type cardProps = {
  uid: string;
  name: string;
  description: string;
  applications: applicationProps[];
  created_by: string;
  creation_date: string | Date;
  tags: Array<{
    name: string;
    font_color: string;
    background_color: string;
  }>;
};

declare class Manager extends EventEmitter {
  static viewinitialized: string;
  static viewerset: string;
  static tokenset: string;
  private _apm;
  private _tokens;
  constructor(apm: ApmBase);
  initViewer(options: {
    project_uid: string;
    start_position?: {
      easting: number;
      northing: number;
      epsg?: number;
    };
    start_campaign?: {
      id: string;
    };
    map_expand?: boolean;
    show_cockpit?: boolean;
    show_mapWindow?: boolean;
    show_toolbar?: boolean;
    show_topbar?: boolean;
    toolbar?: string;
  }): Promise<Viewer>;
  getProjects(): Promise<cardProps[]>;
  setViewer(viewer: InternalViewer): void;
  setTokens(tokens: any): void;
  setApmUserContext(userContext?: {
    id?: string;
    username?: string;
    email?: string;
  }): void;
}

declare type accessTokenResponseType = {
  access_token: string;
  expires_in: number;
  token_type: "Bearer";
};

export declare function getAccessToken(
  url: string,
  client_id: string,
  client_secret: string
): Promise<accessTokenResponseType>;

export declare function init(
  rootId: string,
  token: string,
  userContext?: {
    id?: string;
    username?: string;
    email?: string;
  }
): Promise<Manager>;

export declare function destroy(): void;

export declare function getManager(): Manager;

export declare function getGuestAccessToken(): Promise<accessTokenResponseType>;

declare type tokenTypeWithProvider = {
  domain: string;
  clientId: string;
  access_token: string;
  expires_in: number;
  id_token?: string;
  refresh_token: string;
  token_type: string;
};

export declare function getAccessTokenFromInteractiveLogin(
  rootId: string,
  tenant?: string
): Promise<tokenTypeWithProvider>;

declare type refreshTokenType = {
  access_token: string;
  expires_in: number;
  id_token: string;
  token_type: string;
};

export declare function getAccessTokenFromRefresh(
  url: string,
  clientId: string,
  refreshToken: string
): Promise<refreshTokenType>;

export declare function refreshToken(token: string): void;