// Type definitions for reductor 0.8.0
// Project: https://github.com/mbensch/reductor
// Definitions by: Marcel Bensch <https://github.com/mbensch>

type Action = {
    type: string
    payload?: any
    error?: boolean
    meta?: any
};

type PayloadCreator<T> = (...args: any[]) => T;
type MetaCreator = (...args: any[]) => any;

type Reducer<T> = (state: T, action: Action) => T;

type ReducerMap<T> = {
    [actionType: string]: Reducer<T>
};

type Dispatch = (action:any) => any;

interface MiddlewareAPI<S> {
    dispatch:Dispatch;
    getState():S;
}

interface Middleware {
    <S>(api:MiddlewareAPI<S>):(next:Dispatch) => (action:any) => any;
}

interface Unsubscribe {
    ():void;
}

interface Store<S> {
    dispatch:Dispatch;
    getState():S;
    subscribe(listener:() => void): Unsubscribe;
    replaceReducer(nextReducer: Reducer<S>):void;
}

interface StoreCreator {
    <S>(reducer:Reducer<S>, enhancer?:StoreEnhancer):Store<S>;
    <S>(reducer:Reducer<S>, initialState:S,
        enhancer?:StoreEnhancer):Store<S>;
}

type StoreEnhancer = (next:StoreCreator) => StoreCreator;

declare namespace __Reductor {

    interface ActionMapObject {
        [key:string]: Action;
    }

    interface ActionTypeMapObject {
        [key:string]: string;
    }

    type Selector<TInput, TOutput> = (state: TInput, props?: any) => TOutput;

    interface SelectorMapObject {
        [key:string]: Selector;
    }

    class Application<TState> {
        getName(): string;
        setName(name: string): void;
        name(name: string): Application<TState>;
        getVersion(): string;
        setVersion(version: string): void;
        version(version: string): Application<TState>;
        getKey(): string;
        setKey(key: string, transform?: boolean)
        key(key: string, transform?: boolean): Application<TState>;
        getMount(): Node;
        setMount(node: Node): void;
        mount(node: Node): Application<TState>;
        addModule(module: Module): Application<TState>;
        getModule(key: string): Module;
        getActionTypes(): ActionTypeMapObject;
        addMiddleware(middleware: Middleware): Application<TState>;
        addEnhancer(enhancer: StoreEnhancer): Application<TState>;
        isDebug(): boolean;
        debug(): Application<TState>;
        useHistoryApi(): Application<TState>;
        getRoutes(): Array;
        setRoutes(routes: Array);
        routes(routes: Array)
        getStore(): Store<TState>;
        getHistory(): Object;
        run(): void;
        getState(): TState;
        dispatch(action: Action): Dispatch;
        subscribe(listener: () => void): Unsubscribe;
        replaceReducer(nextReducer: Reducer<TState>): void;
    }

    class Module<TState> {
        getName(): string;
        setName(name: string): void;
        name(name: string): Module<TState>;
        getKey(): string;
        setKey(key: string)
        key(key: string): Module<TState>;
        getVersion(): string;
        setVersion(version: string): void;
        version(version: string): Module<TState>;
        connect(component: any, selectorMap?: SelectorMapObject): any;
        getComponent(name: string): any;
        addComponent(name: string, component: any, selectorMap?: SelectorMapObject, connected?: boolean): Module<TState>;
        getInitialState(): TState;
        setInitialState(state: TState): void;
        initialState(state: TState): Module<TState>;
        on(actionType: string, reducer: Reducer<TState> | ReducerMap<TState>, payloadCreator?: PayloadCreator<TState>, metaCreator?: MetaCreator ): Module<TState>;
        getReducer(): Reducer<TState>;
        getActionTypes(): ActionTypeMapObject;
        getActions(): ActionMapObject;
        decorate(name: string, decorator: any): Module<TState>;
    }
}

declare namespace __Reductor_Helpers {

    enum LogLevel {
        LOG, DEBUG, INFO, SUCCESS, WARNING, ERROR
    }

    interface Logger {
        log(level: LogLevel, message: any[], data?: any[]): void;
        debug( message: any[], data?: any[]): void;
        info(message: any[], data?: any[]): void;
        success(message: any[], data?: any[]): void;
        warning(message: any[], data?: any[]): void;
        error(message: any[], data?: any[]): void;
    }
}

declare module "reductor" {
    export = __Reductor;
}

declare module "reductor.helpers" {
    export = __Reductor_Helpers;
}