'use strict';

import ReactNative from 'react-native';
import DetailService from '../../services/DetailService';

const {
	BRAND_INFO_REQUEST,
	BRAND_INFO_SUCCESS,
	BRAND_INFO_FAILURE,

	JUMP_WITH_URL,


	SET_BRAND_ID,
	SET_GENDER,
	SET_UDID,

	BRADN_FAV_REQUEST,
	BRADN_FAV_SUCCESS,
	BRADN_FAV_FAILURE,


	NEW_ARRIVE_REQUEST,
	NEW_ARRIVE_SUCCESS,
	NEW_ARRIVE_FAILURE,

	ARTICLE_BY_BRAND_REQUEST,
	ARTICLE_BY_BRAND_SUCCESS,
	ARTICLE_BY_BRAND_FAILURE,

	ADD_FAVORITE_REQUEST,
	ADD_FAVORITE_SUCCESS,
	ADD_FAVORITE_FAILURE,

	CANCEL_FAVORITE_REQUEST,
	CANCEL_FAVORITE_SUCCESS,
	CANCEL_FAVORITE_FAILURE,

	PRAISE_ARTICLE_REQUEST,
    PRAISE_ARTICLE_SUCCESS,
    PRAISE_ARTICLE_FAILURE,

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

export function jumpWithUrl(url) {
	if (!url) {
		__DEV__ && console.log('Illegal url');
		return;
	}

    ReactNative.NativeModules.YH_PlustarHelper.jumpWithUrl(url);
    return {
        type: JUMP_WITH_URL,
		payload: url
    };
}


export function brandInfoRequest(key) {
    return {
        type: BRAND_INFO_REQUEST,
		payload: key
    };
}

export function brandInfoSuccess(json) {
    return {
        type: BRAND_INFO_SUCCESS,
        payload: json
    };
}

export function brandInfoFailure(error) {
    return {
        type: BRAND_INFO_FAILURE,
        payload: error
    };
}

/*
 * index number 请求数据的index
 * reload bool 是否需要强制重新请求数据，
 */
export function brandInfo(brandId, reload = false) {
	return (dispatch, getState) => {
		let {app, detail} = getState();
        let item = detail.get('brandInfo');
		if (reload) {
			// 强制刷新数据
		} else {
			if (item.isFetching) {
				return;
			}
		}

		dispatch(brandInfoRequest());
        return new DetailService().getBrandInfo(brandId)
        .then(json => {
			console.log('----->>>>');
			console.log(json);
			let brandIntro = removeHtmlTag(json.brand_intro);
			json.brand_intro = brandIntro;
            dispatch(brandInfoSuccess(json));
        })
        .catch(error => {
            dispatch(brandInfoFailure(error));
        });
	};
}

function removeHtmlTag(str) {
	str = str.replace(/<\/?[^>]*>/g,''); //去除HTML tag
    str = str.replace(/[ | ]*\n/g,''); //去除行尾空白
    str=str.replace(/&nbsp;/ig,'');//去掉&nbsp;
	str = str.replace(/\n[\s| | ]*\r/g,''); //去除多余空行
    return str;
}

export function setBrandId(brandId){
	return {
        type: SET_BRAND_ID,
        payload:brandId
    };
}

export function setGender(gender) {
    return {
        type: SET_GENDER,
        payload: gender,
    };
}

export function setUdid(udid){
	return {
        type: SET_UDID,
        payload:udid
    };
}

export function uidBrandFavRequest(){
 	return {
        type: BRADN_FAV_REQUEST,
    };
}

export function uidBrandFavSuccess(json){
	return {
        type: BRADN_FAV_SUCCESS,
        payload:json
    };
}

export function uidBrandFavFailure(){
	return {
        type: BRADN_FAV_FAILURE,
    };
}

export function uidBrandFav(){
	return (dispatch, getState) => {
		let {app,detail} = getState();
	    let {brandId} = detail;
	    if (!brandId) {
	       	return;
	    }

	    let fetchUidBrandFav = (brandId,uid) => {
				dispatch(uidBrandFavRequest());
	            return new DetailService(app.servicehost).getUidBrandFav(brandId,uid)
		        .then(json=>{
		        	dispatch(uidBrandFavSuccess(json));
		        })
		        .catch(error=>{
		        	dispatch(uidBrandFavFailure());
		        });
			}
		ReactNative.NativeModules.YH_CommonHelper.uid()
			.then(uid => {
				fetchUidBrandFav(brandId, uid);
			})
			.catch(error => {

			});
	};
}


export function newArriveRequest(){
	return {
        type: NEW_ARRIVE_REQUEST,
    };
}

export function newArriveSuccess(json){
	return {
        type: NEW_ARRIVE_SUCCESS,
        payload:json
    };
}

export function newArriveFailure(){
	return {
        type: NEW_ARRIVE_FAILURE,
    };
}

export function newArrive(){
	return (dispatch, getState) => {
		let {detail,app} = getState();
        let {brandId,gender} = detail;
        if (!brandId) {
            return;
        }
        dispatch(newArriveRequest());
        return new DetailService(app.host).getNew(brandId,gender)
        .then(json=>{
        	let payload = json.product_list;
        	dispatch(newArriveSuccess(payload));
        })
        .catch(error=>{
        	dispatch(newArriveFailure());
        });
	}
}

export function articleByBrandRequest(){
	return {
        type: ARTICLE_BY_BRAND_REQUEST,
    };
}

export function articleByBrandSuccess(json){
	return {
        type: ARTICLE_BY_BRAND_SUCCESS,
        payload:json
    };
}

export function articleByBrandFailure(){
	return {
        type: ARTICLE_BY_BRAND_FAILURE,
    };
}
export function articleByBrand(){
	return (dispatch, getState) => {
		let {detail,app} = getState();
		    let {brandId} = detail;
		    if (!brandId) {
		       	return;
		    }

		    let fetchUidBrandFav = (brandId,uid) => {
					dispatch(articleByBrandRequest());
		            return new DetailService(app.servicehost).getArticleByBrand(brandId,uid)
			        .then(json=>{
			        	let payload = json;
			        	dispatch(articleByBrandSuccess(payload));
			        })
			        .catch(error=>{
			        	dispatch(articleByBrandFailure());
			        });
				}
			ReactNative.NativeModules.YH_CommonHelper.uid()
				.then(uid => {
					fetchUidBrandFav(brandId, uid);
				})
				.catch(error => {
					fetchUidBrandFav(brandId, 0);
				});
	};
}
export function addFavoriteRequest(){
	return {
        type: ADD_FAVORITE_REQUEST,
    };
}

export function addFavoriteSuccess(json){
	return {
        type: ADD_FAVORITE_SUCCESS,
        payload:json
    };
}

export function addFavoriteFailure(){
	return {
        type: ADD_FAVORITE_SUCCESS,
    };
}

export function addFavorite() {
	return (dispatch, getState) => {
		let {app, detail} = getState();
        let {brandId} = detail;

        let favoriteRequest = (brandId, uid) => {
			dispatch(addFavoriteRequest());
			dispatch(addFavoriteSuccess());
        	return new DetailService(app.host).addFavorite(brandId, uid)
	        .then(json => {
			})
			.catch(error => {
				dispatch(addFavoriteFailure(error));
			});
        }

		ReactNative.NativeModules.YH_CommonHelper.uid()
		.then(uid => {
			favoriteRequest(shopId, shopId, uid);
		})
		.catch(error => {
			ReactNative.NativeModules.YH_CommonHelper.login()
			.then(uid => {
				favoriteRequest(shopId, shopId, uid);
			})
			.catch(error => {

			});
		});
	};
}

export function cancelFavoriteRequest(){
	return {
        type: CANCEL_FAVORITE_REQUEST,
    };
}

export function cancelFavoriteSuccess(json){
	return {
        type: CANCEL_FAVORITE_SUCCESS,
        payload:json
    };
}

export function cancelFavoriteFailure(){
	return {
        type: CANCEL_FAVORITE_FAILURE,
    };
}

export function cancelFavorite() {
	return (dispatch, getState) => {
		let {app, detail} = getState();
        let {brandId} = detail;

        let favoriteRequest = (brandId, uid) => {
			dispatch(cancelFavoriteRequest());
			dispatch(cancelFavoriteSuccess());
        	return new DetailService(app.host).cancelFavorite(brandId, uid)
	        .then(json => {
			})
			.catch(error => {
				dispatch(cancelFavoriteFailure(error));
			});
        }

		ReactNative.NativeModules.YH_CommonHelper.uid()
		.then(uid => {
			favoriteRequest(shopId, shopId, uid);
		})
		.catch(error => {
			ReactNative.NativeModules.YH_CommonHelper.login()
			.then(uid => {
				favoriteRequest(shopId, shopId, uid);
			})
			.catch(error => {

			});
		});
	};
}


export function praiseArticleRequest(){
	return {
        type: PRAISE_ARTICLE_REQUEST,
    };
}

export function praiseArticleSuccess(json){
	return {
        type: PRAISE_ARTICLE_SUCCESS,
        payload:json
    };
}

export function praiseArticleFailure(error){
	return {
        type: PRAISE_ARTICLE_FAILURE,
        payload:error
    };
}

export function praiseArticle(articleId, opt) {
	return (dispatch, getState) => {
		let {app, detail} = getState();
		let {udid} = detail;
		console.log("chenlin", "getState:" + JSON.stringify(getState()));

		let articleRequest = (articleId, udid, opt) => {
			dispatch(praiseArticleRequest());
            return new DetailService(app.servicehost).praiseArticle(articleId, udid, opt)
	        .then(json=>{
	        	dispatch(praiseArticleSuccess(json));
	        })
	        .catch(error=>{
	        	dispatch(praiseArticleFailure(error));
	        });
		}

		articleRequest(articleId, udid, opt);

		
	};
}