export default function reducer(state: LightsState = initialState, action: any = {}) {  
  switch (action.type) {
    case SHOW_SELECTOR:
      return assign({}, state, { showLightSelector: action.show });
    case SELECT_LIGHT:
      return assign({}, state, { selectedIndex: action.selectedLight.index });
    case SET_LIGHTS:
      return assign({}, state, {
        lights: action.lights,
        selectedIndex: 0,
      });
    case UPDATE_LIGHT_COLOR:
      setSelectedLight(state, assign({}, getSelectedLight(state), { color: action.color }));
      saveLights(state.lights);
      return assign({}, state, { list: [...state.lights] });
    case UPDATE_LIGHT_RADIUS:
      setSelectedLight(state, assign({}, getSelectedLight(state), { radius: action.radius }));
      saveLights(state.lights);
      return assign({}, state, { list: [...state.lights] });
    case UPDATE_LIGHT_INTENSITY:
      setSelectedLight(state, assign({}, getSelectedLight(state), { intensity: action.intensity }));
      saveLights(state.lights);
      return assign({}, state, { list: [...state.lights] });
    default: return state;
  }
}

export const trackerStore = (state = initialState, action: Action): TrackerState => {
  switch (action.type) {
    case ActionType.UPDATE_AUTH_FORM:
      return objectAssign({}, state, {loginForm: action.loginForm});
    case ActionType.AUTHENTICATED:
      return objectAssign({}, state, {authenticated: true});
    case ActionType.NOT_AUTHENTICATED:
      return objectAssign({}, state, {authenticated: false});
    case ActionType.SET_CONFIG:
      return objectAssign({}, state, {config: action.config, profileId: action.profileId});
    default:
      return state;
  }
};

function processPosts(params: IPostProcessingParams) {
    const { action, count, pageSize } = params;
    const current = params.state[action.props.id] || { count, pageSize, pages: {} };
    const currentPage = current.pages[action.props.page];
    const itemSet: Pages = objectAssign({}, current.pages, {
        [action.props.page]: pageReducer(currentPage, params.action)
    });
    const nestedPage: IItemPages = {
        pages: itemSet,
        count: count !== undefined ? count : current.count,
        pageSize: pageSize !== undefined ? pageSize : current.pageSize
    };
    return objectAssign({}, params.state, {
        [action.props.id]: nestedPage
    });
}

function addGroups(current: ItemMap, groups: IForumGroup[]): ItemMap {
    let map: ItemMap = {};
    for (const item of groups) {
        map[item.id] = objectAssign({}, current[item.id], item);
    }
    return map;
}

 static saveLocal(data: TrackingBundle): Rx.Subject<string> {
   return recordStore.put(assign({
     _id              : `${data.context.timestamp}-${data.context.href}`,
     navigationTiming : data.navigationTiming,
     chromeLoadTimes  : data.chromeLoadTimes
   }, data.context))
 }

export default function reducer(state: BuildingState = initialState, action: any = {}) {
  switch (action.type) {
    case CHANGE_MODE:
      return assign({}, state, { mode: action.mode });
    default: return state;
  }
}

function byId(state: ItemMap = {}, action: Action): ItemMap {
    switch (action.type) {
        case 'RECEIVED_FORUM_POST_UPDATE':
        return objectAssign({}, state, {[action.post.id]: action.post});
        case 'RECEIVED_FORUM_GROUPS':
        case 'RECEIVED_FORUM_TOPIC':
        case 'RECEIVED_FORUM_THREAD':
        case 'RECEIVED_NEWS_POST':
            let map: ItemMap = {};
            for (const item of action.props.data.posts) {
                map[item.id] = item;
            }
            return objectAssign({}, state, map);
        default:
            return state;
    }
}

export default function reducer(state: MaterialsReplaceState = initialState, action: any = {}) {
  switch (action.type) {
    case BLOCKS_SELECTED:
      return assign({}, state, {
        blocksSelected: action.selected,
      });
    case SELECT_FROM_MATERIAL:
      return assign({}, state, {
        from: action.selectedMaterial,
      });
    case SELECT_TO_MATERIAL:
      return assign({}, state, {
        to: action.selectedMaterial,
      });
    default: return state;
  }
}

function removeTopic(group: IForumGroup, topicId: number): IForumGroup {
    if (group && group.topics) {
        const topics = group.topics.filter((topic: number) => {
            return topic !== topicId;
        });
        return objectAssign({}, group, { topics });
    }
    return group;
}

export default function reducer(state: BlueprintsState = initialState, action: any = {}) {
  switch (action.type) {
    case UPDATE_BLUEPRINTS:
      return assign({}, state, {
        blueprints: [...action.blueprints],
      });
    case SELECT_BLUEPRINT:
      return assign({}, state, {
        selected: action.blueprint,
      });
    case MODE_CHANGED:
      return assign({}, state, {
        copyable: action.copy === undefined ? state.copyable : action.copy,
        pastable: action.paste === undefined ? state.pastable : action.paste,
      });
    default: return state;
  }
}

function assign() {
  return objectAssign({hellow: "world"}, {source1: "U"}, {source2: "V"}, {source3: "W"}, {source4: "Q"}, {source5: "R"}, {
    hellow: "hellow",
    source1: "source1",
    source2: "source2",
    source3: "source3",
    source4: "source4",
    source5: "source5",
    generic: "any"
  });
}

export default function reducer(state: MaterialsState = initialState, action: any = {}) {
  switch (action.type) {
    case SET_MATERIALS:
      return assign({}, state, {
        materials: action.materials,
        selectedMaterial: action.materials[0],
        selectedBlock: action.materials[0].blocks[0],
      });
    case SELECT_MATERIAL:
      return assign({}, state, {
        selectedMaterial: action.selectedMaterial,
      });
    case SELECT_BLOCK:
      const block: BuildingBlock = action.selectedBlock;
      const newState: MaterialsState = { selectedBlock: block } as MaterialsState;
      if (state.selectedMaterial.id !== block.materialId)
        newState.selectedMaterial = getMaterialById(block.materialId, state.materials);
      return assign({}, state, newState);
    default: return state;
  }
}

export function post<T>(options: IPostRequestOptions): Promise<T> {
    const headers = assign({
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    }, options.headers || {});
    if (options.token) {
        headers['Authorization'] = `Token ${options.token}`;
    }
    const formatted = !options.data || typeof options.data === 'string' || options.data instanceof File;
    const data = formatted ? options.data : JSON.stringify(options.data);
    return makeRequest<T>({ url: options.url, method: 'POST', headers, data });
}

function byTorrentId(state: Peers = {}, action: Action): Peers {
    switch (action.type) {
        case 'REQUEST_PEERS':
        case 'RECEIVED_PEERS':
        case 'FAILED_PEERS':
            const currentItemSet = state[action.props.id];
            const newItemSet = torrentPagesReducer(currentItemSet, action);
            return objectAssign({}, state, { [action.props.id]: newItemSet });
        default:
            return state;
    }
}

export function addLoadedNode<T extends IItem>(current: INodeMap<T>, item: T): INodeMap<T> {
    const node: IItemNode<T> = {
        status: {
            loading: false,
            loaded: true,
            failed: false,
            outdated: false
        },
        item: item
    };
    return objectAssign({}, current, { [item.id]: node });
}

function byReleaseId(state: Torrents = {}, action: Action): Torrents {
    switch (action.type) {
        case 'REQUEST_RELEASE_TORRENTS':
        case 'RECEIVED_RELEASE_TORRENTS':
        case 'FAILED_RELEASE_TORRENTS':
        case 'INVALIDATE_RELEASE_TORRENTS':
            const currentItemSet = state[action.props.id];
            const newItemSet = releasePagesReducer(currentItemSet, action);
            return objectAssign({}, state, { [action.props.id]: newItemSet });
        default:
            return state;
    }
}

function byFilmId(state: Comments = {}, action: Action): Comments {
    switch (action.type) {
        case 'REQUEST_COMMENTS':
        case 'RECEIVED_COMMENTS':
        case 'FAILED_COMMENTS':
        case 'INVALIDATE_COMMENTS':
            const currentItemSet = state[action.props.id];
            const newItemSet = filmPagesReducer(currentItemSet, action);
            return objectAssign({}, state, { [action.props.id]: newItemSet });
        default:
            return state;
    }
}

export default function reducer(state: MaterialsByTypeState = initialState, action: any = {}) {
  switch (action.type) {
    case SET_MATERIALS_BY_TYPE:
      return assign({}, state, {
        materialsByType: action.matsByType,
      });
    case UPDATE_MATERIAL_SELECTOR:
      return assign({}, state, {
        onMaterialSelected: action.onSelect,
        selectedMaterial: action.selection,
      });
    case SET_MATERIAL_SELECTION:
      return assign({}, state, {
        selectedMaterial: action.selection,
      });
    case SET_MATERIAL_HOVER:
      return assign({}, state, {
        hoverMaterial: action.material,
      });
    default: return state;
  }
}

 function pages(state: Pages = {}, action: any): Pages {
     switch (action.type) {
         case fetchingType:
         case receivedType:
         case failedType:
         case failedType:
         case invalidateType:
             const page: IItemPage = pageReducer(state[action.props.page], action);
             return objectAssign({}, state, { [action.props.page]: page });
         default:
             return state;
     }
 }

function byId(state: ItemMap = {}, action: Action): ItemMap {
    switch (action.type) {
        case 'RECEIVED_INVITE_DELETION':
            const copy = objectAssign({}, state);
            delete copy[action.props.id];
            return copy;
        case 'RECEIVED_NEW_INVITE':
            return addLoadedNode(state, action.invite);
        case 'RECEIVED_INVITES':
            return addLoadedNodes(state, action.props.items);
        default:
            return state;
    }
}