'use strict';

import ReactNative from 'react-native';
import CategoryBService from '../../services/CategoryBService';
import Immutable, {Map} from 'immutable';
const {
	SET_TYPE,

    GET_CATEGORY_B_LIST_REQUEST,
    GET_CATEGORY_B_LIST_SUCCESS,
    GET_CATEGORY_B_LIST_FAILURE,

    GET_CATEGORY_B_SUBDETAIL_REQUEST,
    GET_CATEGORY_B_SUBDETAIL_SUCCESS,
    GET_CATEGORY_B_SUBDETAIL_FAILURE,

	SET_CURRENT_CATEGORY_B,
	SET_CURRENT_CHANNEL_B,

	SET_CURRENT_CATEGORY_B_SUBDETAIL_FROM_CACHE,

	JUMP_TO_CATEGORY,

} = require('../../constants/actionTypes').default;

export function getCategoryBList(channel_id) {
	return (dispatch, getState) => {
		let {app, classify} = getState();

		dispatch(getCategoryBListRequest());

		return new CategoryBService(app.host).getCategoryBList()
        .then(json => {
			dispatch(getCategoryBListSuccess(json));

			dispatch(getCategoryBFirstSubCategoryDetail(channel_id));
		})
		.catch(error => {
			dispatch(getCategoryBListFailure());
		});
	};
}


/**
 * 获取子分类的数据，逻辑上先判断缓存数据是否存在，不存在则从网络获取
 **/
export function getCategoryBSubCategoryDetail(category_id, category_value){

	return (dispatch, getState) => {

		let {categoryB} = getState();

		let currentChannelId = categoryB.currentChannelId;

		//检查缓存是否存在数据，如果不存在则获取
        let cache = categoryB.cacheSubCateData;
        let key = getSubDetailCacheKey(currentChannelId, category_id);
        let categoryData = cache.get(key);

        //设置当前的类别信息
        dispatch(setCurrentCateB(category_id, category_value));

		//未命中，访问网络数据
        if (!categoryData) {
            // console.log("chenlin", "未命中缓存，调用接口访问数据：" + key);
            dispatch(getCategoryBSubDetail(currentChannelId, category_id));
        }
        //已命中，展示缓存数据
        else{
            // console.log("chenlin", "命中缓存：" + JSON.stringify(categoryData));
            dispatch(getCategoryBSubDetailData(categoryData));
        }

	};
}

/**
 *	获取子分类
 **/
function getSubDetailCacheKey(channel_id, category_id){
	let key = "CHA_" + channel_id + "_CAT_" + category_id;
	return key;
}


/**
 * 网络获取子分类的数据
 **/
export function getCategoryBSubDetail(channel_id, category_id) {
	return (dispatch, getState) => {
		let {app, categoryB} = getState();

		//各频道固定资源位
		let content_code = '';
		if(channel_id == '1'){
			content_code = 'daaa8b1a5103a30419ebd79c06e6feac';
		}
		else if(channel_id == '2'){
			content_code = '1a18449fa785631b302dc6d27388bf93';
		}
		else if(channel_id == '3'){
			content_code = '591152bee9fddcb0b4f793aa38304cb5';
		}
		else if(channel_id == '4'){
			content_code = 'e823582db5ead63c82e0d348c4e6a6bb';
		}

		dispatch(getCategoryBSubDetailRequest());

		return new CategoryBService(app.host).getCategoryBSubDetail(channel_id, category_id, content_code)
        .then(json => {
        	let payload = parseCategoryBSubDetail(channel_id, category_id, json, categoryB);
			dispatch(getCategoryBSubDetailSuccess(payload));
		})
		.catch(error => {
			dispatch(getCategoryBSubDetailFailure());
		});
	};
}

/**
 *获取指定channel的第一个分类数据
 **/
export function getCategoryBFirstSubCategoryDetail(channel_id) {

	return (dispatch, getState) => {
		let {categoryB} = getState();

		let categoryList = categoryB.categoryList;

		let category = null;
		if(channel_id == '1'){
			category = categoryList.get('boy').get(0);
		}
		else if(channel_id == '2'){
			category = categoryList.get('girl').get(0);
		}
		else if(channel_id == '3'){
			category = categoryList.get('kids').get(0);
		}
		else if(channel_id == '4'){
			category = categoryList.get('lifestyle').get(0);
		}
		dispatch(getCategoryBSubCategoryDetail(category.get('category_id'), category.get('category_name')));
	};
}


/**
 *在子分类的数据尾部添加一个MORE，因为需要获取relation_parameter 和 node_count数据，所以不得不从分类列表中筛选找出
 **/
function parseCategoryBSubDetail(channel_id, category_id, subcategory_data, props_data) {
	if(!subcategory_data || !props_data){
		return;
	}

	//分类信息不为空时，添加more
	if(subcategory_data.sortInfo){

		//获取当前频道下一级分类列表信息
		let categoryData = props_data.categoryList.get(props_data.currentChannelValue);

		//获取指定category_id分类信息
		let category = null; 
		categoryData.map((item, i) => {
			if(category_id == item.get('category_id')){
				category = item;
			}
		});

		let more = {
            category_name: 'more',
            parent_id: category_id,
            relation_parameter: category ? category.get('relation_parameter') : {},
            node_count: category ? category.get('node_count') : 0,
            data_type:'text',
        };


		subcategory_data.sortInfo.push(more);
	}

	let key = getSubDetailCacheKey(channel_id, category_id);

	// console.log("chenlin", "parseCategoryBSubDetail处理后的JSON数据：" + JSON.stringify(data));


	return {key: key, data: subcategory_data};

}


export function getCategoryBListRequest() {
    return {
        type: GET_CATEGORY_B_LIST_REQUEST,
    };
}

export function getCategoryBListSuccess(json) {
    return {
        type: GET_CATEGORY_B_LIST_SUCCESS,
        payload: json
    }
}

export function getCategoryBListFailure(error) {
    return {
        type: GET_CATEGORY_B_LIST_FAILURE,
        payload: error
    }
}

export function getCategoryBSubDetailRequest() {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_REQUEST,
    };
}

export function getCategoryBSubDetailSuccess(json) {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_SUCCESS,
        payload: json
    }
}

export function getCategoryBSubDetailFailure(error) {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_FAILURE,
        payload: error
    }
}


export function setCurrentCateB(categoryId, categoryValue){
	return {
        type: SET_CURRENT_CATEGORY_B,
        payload: {id: categoryId, value : categoryValue}
    }
}

export function setCurrentChannelB(channelId, channelValue){
	return {
        type: SET_CURRENT_CHANNEL_B,
        payload: {id: channelId, value : channelValue}
    }
}

export function getCategoryBSubDetailData(categoryData) {
	return {
        type: SET_CURRENT_CATEGORY_B_SUBDETAIL_FROM_CACHE,
        payload: categoryData
    }
}


export function jumpToCategory(value, index, channelId){
	ReactNative.NativeModules.YH_CommonHelper.jumpToCategory(value, parseInt(index), parseInt(channelId));
	return {
        type: JUMP_TO_CATEGORY,
        payload: value
    }
}