export default function reducer(state: BlueprintsState = initialState, action: any = {}) {
  switch (action.type) {
    case SELECT_BLUEPRINT:
      return assign({}, state, {
        selected: action.blueprint
      });
    case ADD_BLUEPRINT:
      return assign({}, state, {
        blueprints: [...state.blueprints, action.blueprint]
      });
    case ADD_BLUEPRINT_ICON:
      action.blueprint.icon = action.icon;
      return assign({}, state, {
        blueprints: [...state.blueprints]
      });
    case REMOVE_BLUEPRINT:
      return assign({}, state, {
        blueprints: remove(state.blueprints, 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;
  }
}

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 default function reducer(state: MaterialsReplaceState = initialState, action: any = {}) {
  switch (action.type) {
    case SELECT_FROM_MATERIAL:
      return assign({}, state, {
        from: action.selectedMaterial,
      });
    case SELECT_TO_MATERIAL:
      return assign({}, state, {
        to: action.selectedMaterial,
      });
    default: return state;
  }
}

 mergeMap((arg) : Observable<IPipelineLoaderEvent<T, U>> => {
   // "cache": data taken from cache by the pipeline
   // "data": the data is available but no request has been done
   // "response": data received through a request
   switch (arg.type) {
     case "cache":
     case "data":
     case "response":
       const response$ = observableOf({
         type: "response" as "response",
         value: objectAssign({}, resolverResponse, {
           url: arg.type === "response" ? arg.value.url : undefined,
           responseData: arg.value.responseData,
           sendingTime: arg.type === "response" ?
             arg.value.sendingTime : undefined,
           receivedTime: arg.type === "response" ?
             arg.value.receivedTime : undefined,
         }),
       });
       const metrics$ = arg.type !== "response" ?
         EMPTY : observableOf({
           type: "metrics" as "metrics",
           value: {
             size: arg.value.size,
             duration: arg.value.duration,
           },
         });
       return observableConcat(response$, metrics$);
     default:
       return observableOf(arg);
   }
 }));

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

/**
 * @param {Element} root
 * @returns {Object}
 */
export default function parseSegmentList(root: Element) : IParsedSegmentList {
  const base = parseSegmentBase(root);
  const list : IParsedSegmentURL[] = [];

  const segmentListChildren = root.childNodes;
  for (let i = 0; i < segmentListChildren.length; i++) {
    if (segmentListChildren[i].nodeType === Node.ELEMENT_NODE) {
      const currentNode = segmentListChildren[i] as Element;
      if (currentNode.nodeName === "SegmentURL") {
        const segmentURL = parseSegmentURL(currentNode);
        list.push(segmentURL);
      }
    }
  }

  const baseDuration = base.duration;

  if (baseDuration == null) {
    throw new Error("Invalid SegmentList: no duration");
  }

  return objectAssign(base, {
    list,
    duration: baseDuration, // Ugly but TS is too dumb there
  });
}

const blocks = (state: BlocksState = initialBlocksState, action: any): BlocksState => {
  switch(action.type) {
    case 'LOAD_BLOCKS':
      return assign({}, state, { blocksLoaded: 0 });
    case 'RECV_BLOCKS':
      return assign({}, state, { blocksLoaded: action.when });
    case 'LOAD_BLUEPRINTS':
      return assign({}, state, { blueprintsLoaded: 0 });
    case 'RECV_BLUEPRINTS':
      return assign({}, state, { blueprintsLoaded: action.when });
    case 'COPY_BLUEPRINT':
      return assign({}, state, { blueprintCopied: action.when });
  }
  return state;
}

    const representations = qualityLevels.map((qualityLevel) => {
      const path = resolveURL(rootURL, baseURL);
      const repIndex = {
        timeline: index.timeline,
        timescale: index.timescale,
        media: replaceRepresentationSmoothTokens(path, qualityLevel.bitrate),
        isLive,
        timeShiftBufferDepth,
        manifestReceivedTime,
      };
      const mimeType = qualityLevel.mimeType || DEFAULT_MIME_TYPES[adaptationType];
      const codecs = qualityLevel.codecs || DEFAULT_CODECS[adaptationType];
      const id =  adaptationID + "_" + adaptationType + "-" + mimeType + "-" +
        codecs + "-" + qualityLevel.bitrate;

      const contentProtections : IContentProtection[] = [];
      let firstProtection : IContentProtectionSmooth|undefined;
      if (protections.length) {
        firstProtection = protections[0];
        protections.forEach((protection) => {
          const keyId = protection.keyId;
          protection.keySystems.forEach((keySystem) => {
            contentProtections.push({
              keyId,
              systemId: keySystem.systemId,
            });
          });
        });
      }

      const segmentPrivateInfos = {
        bitsPerSample: qualityLevel.bitsPerSample,
        channels: qualityLevel.channels,
        codecPrivateData: qualityLevel.codecPrivateData || "",
        packetSize: qualityLevel.packetSize,
        samplingRate: qualityLevel.samplingRate,

        // TODO set multiple protections here instead of the first one
        protection: firstProtection != null ? {
          keyId: firstProtection.keyId,
          keySystems: firstProtection.keySystems,
        } : undefined,
      };

      const representation : IParsedRepresentation = objectAssign({}, qualityLevel, {
        index: new RepresentationIndex(repIndex, {
                 segmentPrivateInfos,
                 aggressiveMode: parserOptions.aggressiveMode == null ?
                   DEFAULT_AGGRESSIVE_MODE : parserOptions.aggressiveMode,
               }),
        mimeType,
        codecs,
        id,
      });
      if (contentProtections.length) {
        representation.contentProtections = contentProtections;
      }
      return representation;
    });

 Object.keys(rulesConfig).forEach(key => {
     if (isPresetRuleKey(key)) {
         // <preset>/<rule>
         objectAssign(filteredConfig, mapRulesConfig(rulesConfig[key], key));
         return;
     }
     filteredConfig[key] = rulesConfig[key];
 });