/**
 * Created by MeePwn
 * https://github.com/maybewaityou
 *
 * description:
 *
 */
import { History, Location, LocationDescriptor, LocationState, Path } from 'history';
import { Map } from 'immutable';
import { Component, ReactNode } from 'react';
import { match } from 'react-router';
import { RouteComponentProps } from 'react-router';
import { Dispatch, Middleware, Reducer, ReducersMapObject, Store } from 'redux';
import { ActionsObservable, StateObservable } from 'redux-observable';
import { Observable } from 'rxjs';

declare enum PlatformType {
  NATIVE,
  FRONTEND,
}

declare const actions: any;
declare const models: any[];
declare const _history: any;
declare const bind: any;
declare const store: any;
declare const connect: any;
declare function defaultMapDispatchToProps(dispatch: any);

type ActionType = string | symbol;

declare interface IAction {
  type: ActionType;
  payload?: any;
}

declare const actionCreator: (actionType: ActionType, payload?: any) => IAction;
declare const createAction: (actionType: ActionType) => (payload?: any) => IAction;

declare const dispatch: any;

declare function flowable(action: IAction): Observable<IAction>;
declare function actionStream(type: string, payload?: any): Observable<IAction>;

declare const acceptActions: (reducer: any, actions?: any) => any;
declare const ignoreActions: (reducer: any, actions?: any) => any;

declare type BatchActionType = 'BATCHING_REDUCER.BATCH_ACTIONS';
declare const BATCH_ACTIONS: BatchActionType;

declare interface IBatchAction extends IAction {
  type: BatchActionType;
  payload: IAction[];
}

declare function batchActions(actions: IAction[], type?: string): IBatchAction;

type Dispatch<S> = <A extends IAction>(action: A) => A;
type Middleware = <S>(api: IMiddlewareAPI<S>) => (next: Dispatch<IAction>) => Dispatch<IAction>;
declare interface IMiddlewareAPI<S> {
  dispatch: Dispatch<IAction>;
  getState(): S;
}

declare const createImmutableActionMiddleware: (ingoreActionTypes?: string[]) => Middleware;
declare const createThunkMiddleware: (store: any) => Middleware;
declare const loggerMiddleware: (store: any) => Middleware;

declare const epicCreator: (action$: any) => (actionType: string | symbol) => (nextAction: any) => typeof Observable;

declare type ActionsObservable = ActionsObservable<IAction>;
declare type StateObservable<S> = StateObservable<S>;

type IEpic = (action$: ActionsObservable<IAction>, store: any, dependencies?: any) => any;

declare function mutate(state: Map<string, any>, mutation: any): Map<string, any>;
declare function unboxing(params: any): any;

type Selector<S, R> = (state: S) => R;
type OutputSelector<S, R, C> = Selector<S, R> & {
  resultFunc: C;
  recomputations: () => number;
  resetRecomputations: () => number;
};

declare function createSelector<S, R1, T>(
  selectors: [Selector<S, R1>],
  combiner: (...res: R1[]) => T,
): OutputSelector<S, T, (res: R1) => T>;

declare function createSelectorCreator(memoize: <F>(func: F) => F): typeof createSelector;

declare function createSelectorCreator<O1>(memoize: <F>(func: F, option1: O1) => F, option1: O1): typeof createSelector;

declare function createSelectorCreator<O1, O2>(
  memoize: <F>(func: F, option1: O1, option2: O2) => F,
  option1: O1,
  option2: O2,
): typeof createSelector;

declare function createSelectorCreator<O1, O2, O3>(
  memoize: <F>(func: F, option1: O1, option2: O2, option3: O3, ...rest: any[]) => F,
  option1: O1,
  option2: O2,
  option3: O3,
  ...rest: any[],
): typeof createSelector;

interface IProviderProps {
  store: any;
  children: ReactNode;
}

declare class Provider extends Component<IProviderProps, {}> {}

declare interface IRouteConfigComponentProps<T> extends RouteComponentProps<T> {
  route?: IRouteConfig;
}

declare type AsyncComponent = () => Promise<any> | any;
declare type AsyncRoute = () => Promise<React.ComponentType<IRouteConfigComponentProps<any> | {}>> | any;

declare interface IRouteConfig {
  location?: Location;
  component?: React.ComponentType<IRouteConfigComponentProps<any> | {}> | AsyncRoute;
  path?: string;
  exact?: boolean;
  strict?: boolean;
  routes?: IRouteConfig[];
}

declare const renderRoutes: (routes: IRouteConfig[], extraProps?: any, switchProps?: any) => any;
declare const routeLoader: (asyncRoute: AsyncRoute) => any;

declare const dynamic: (config: any) => any;
declare const mario: any;

declare interface IConnectedRouterProps<State> {
  store?: Store<State>;
  history: History;
}
declare class ConnectedRouter<State> extends Component<IConnectedRouterProps<State>> {}

declare const LOCATION_CHANGE = '@@router/LOCATION_CHANGE';

declare interface IRouterState {
  location: Location | null;
}

declare const routerReducer: Reducer<IRouterState>;

declare const CALL_HISTORY_METHOD = '@@router/CALL_HISTORY_METHOD';

declare function push(location: LocationDescriptor, state?: LocationState): IRouterAction;
declare function replace(location: LocationDescriptor, state?: LocationState): IRouterAction;
declare function go(n: number): IRouterAction;
declare function goBack(): IRouterAction;
declare function goForward(): IRouterAction;

declare const IRouterActions: {
  push: typeof push;
  replace: typeof replace;
  go: typeof go;
  goBack: typeof goBack;
  goForward: typeof goForward;
};

declare interface ILocationActionPayload {
  method: string;
  args?: any[];
}

declare interface IRouterAction {
  type: typeof CALL_HISTORY_METHOD;
  payload: ILocationActionPayload;
}

declare interface ILocationChangeAction {
  type: typeof LOCATION_CHANGE;
  payload: Location & {
    props?: {
      match: {
        path: string;
        url: string;
        params: any;
        isExact: boolean;
      };
      location: Location;
      history: History;
    };
  };
}

declare function routerMiddleware(history: History): Middleware;

declare interface IRedirectProps {
  to: LocationDescriptor;
  push?: boolean;
  from?: string;
  path?: string;
  exact?: boolean;
  strict?: boolean;
}
declare class Redirect extends Component<IRedirectProps, any> {}

declare interface IRouteProps {
  location?: Location;
  component?: React.ComponentType<RouteComponentProps<any>> | React.ComponentType<any>;
  render?: ((props: RouteComponentProps<any>) => React.ReactNode);
  children?: ((props: RouteComponentProps<any>) => React.ReactNode) | React.ReactNode;
  path?: string;
  exact?: boolean;
  strict?: boolean;
}
declare class Route<T extends IRouteProps = IRouteProps> extends Component<T, any> {}

declare interface ISwitchProps {
  children?: React.ReactNode;
  location?: Location;
}
declare class Switch extends Component<ISwitchProps, any> {}

declare interface ILinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
  to: LocationDescriptor;
  replace?: boolean;
}

declare interface ILinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
  to: LocationDescriptor;
  replace?: boolean;
}
declare class Link extends Component<ILinkProps, any> {}
declare interface INavLinkProps extends ILinkProps {
  activeClassName?: string;
  activeStyle?: React.CSSProperties;
  exact?: boolean;
  strict?: boolean;
  location?: Location;
  isActive?<P>(match: match<P>, location: Location): boolean;
}
declare class NavLink extends Component<INavLinkProps, any> {}