package com.fzzy.api.view.pr;

import com.bstek.dorado.annotation.DataProvider;
import com.bstek.dorado.annotation.DataResolver;
import com.bstek.dorado.annotation.Expose;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.service.ApiCommonService;
import com.fzzy.api.service.ApiPushManager;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.Constant;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.Api1109;
import com.fzzy.api.entity.ApiConfs;
import com.fzzy.api.utils.ContextUtil;
import com.fzzy.api.view.repository.Api1109Rep;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import sun.misc.BASE64Encoder;

import java.io.*;
import java.util.List;

/**
 * 文件信息
 * @author he
 */
@SuppressWarnings("restriction")
@Slf4j
@Component
public class Api1109PR {

	@Autowired
	private Api1109Rep api1109Rep;

	@Autowired
	private ApiCommonService apiCommonService;

	@Autowired
	private ApiPushManager apiPushManager;

	/**
	 * api1109PR#listAll
	 *
	 * @return
	 */
	@DataProvider
	public List<Api1109> listAll() {
		return api1109Rep.findAll();
	}

	/**
	 * api1109PR#updateSave
	 *
	 * @param entity
	 */
	@DataResolver
	public void updateSave(Api1109 entity) {

		// 手动将doradoEntity对象转换为标准Bean对象
		Api1109 data = new Api1109();
		BeanUtils.copyProperties(entity, data);
		if(StringUtils.isEmpty(data.getId())){
			data.setId(ContextUtil.getUUID());
		}

		api1109Rep.save(data);
	}

	/**
	 * api1109PR#delData
	 *
	 * @param data
	 */
	@Expose
	public String delData(Api1109 data) {

		api1109Rep.deleteById(data.getId());

		return null;
	}

	/**
	 * 
	 * 更新删除标记 api1109PR#delUpdate
	 *
	 * @param entity
	 */
	@Expose
	public String delUpdate(Api1109 entity) {

		entity.setCzbz(Constant.CZBZ_D);

		Api1109 data = new Api1109();
		BeanUtils.copyProperties(entity, data);

		api1109Rep.save(data);
		return null;
	}

	/**
	 * api1109PR#pushData
	 *
	 * @param items
	 */
	@Expose
	public String pushData(List<Api1109> items) {
		ResponseDto responseDto;
		String result = "";
		Api1109 d;
		//获取配置
		String kqdm = items.get(0).getKqdm();
		ApiConfs apiConf = apiCommonService.getConf(kqdm);

		if (null == apiConf) return "系统没有获取到当前库区配置信息，执行失败";

		//封装参数
		ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1109);

		//获取实现接口
		ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(param.getPushProtocol());
		if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

		for (Api1109 data : items) {
			d = new Api1109();
			BeanUtils.copyProperties(data, d);
			param.setBizId(data.getBizId());
			responseDto = apiRemoteService.pushData(param, apiConf, d);

			result += responseDto.toString();
			if (responseDto.getSuccess() == 0) {
				if (Constant.CZBZ_I.equals(d.getCzbz())) {
					api1109Rep.updateStatus(data.getKqdm(), Constant.CZBZ_U);
				}
			}
		}
		return result;
	}


	/**
	 * imgFile 图片本地存储路径
	 */
	public static String getImgFileToBase64(String imgFile) {
		//将图片文件转化为字节数组字符串，并对其进行Base64编码处理
		InputStream inputStream = null;
		byte[] buffer = null;
		//读取图片字节数组
		try {
			inputStream = new FileInputStream(imgFile);
			int count = 0;
			while (count == 0) {
				count = inputStream.available();
			}
			buffer = new byte[count];
			inputStream.read(buffer);
		} catch (IOException e) {
			log.error(e.getMessage(),e);
		} finally {
			if (inputStream != null) {
				try {
					// 关闭inputStream流
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		// 对字节数组Base64编码
		//return Base64Utils.encodeToString(buffer);
		 return new BASE64Encoder().encode(buffer);
	}

	/**
	 * 获取图片的二进制流
	 * @param imgPath
	 * @return
	 */
	@SuppressWarnings("resource")
	public String imgToIo(String imgPath){
		//图片转化为二进制
		byte[] imageBytes = null;
		try {
			FileInputStream fileInputStream = new FileInputStream(new File(imgPath));
			imageBytes = new byte[fileInputStream.available()];
			fileInputStream.read(imageBytes);
		} catch (IOException e) {
			System.out.println(e);
			return null;
		}
		return UnicodeByteToStr(imageBytes);
	}

	private static String UnicodeByteToStr(byte[] b){
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<b.length;i++) {
			sb.append(String.format("%02x", b[i]));
		}
		return sb.toString();
	}

	/**
	 * 根据文件路径将文件转为二进制数组
	 * @param filePath:文件路径
	 * @return
	 */
	public static byte[] file2byte(String filePath) {
		byte[] buffer = null;
		try {
			File file = new File(filePath);
			FileInputStream fis = new FileInputStream(file);
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			byte[] b = new byte[1024];
			int n;
			while ((n = fis.read(b)) != -1) {
				bos.write(b, 0, n);
			}
			fis.close();
			bos.close();
			buffer = bos.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return buffer;
	}

	/**
	 * 将二进制数组转为字符串
	 * @param b
	 * @return
	 */
	public static String toHexString(byte[] b) {
		StringBuilder sb = new StringBuilder();
		String stmp="";
		for (int n=0;n<b.length;n++) {
			stmp=(Integer.toHexString(b[n] & 0XFF));
			if (stmp.length()==1) sb.append("0"+stmp);
			else sb.append(stmp);
		}
		return sb.toString().toUpperCase();
	}


	public static void main(String[] args) {
		String hex = toHexString(file2byte("E://91511424746940066Y001.jpg"));
		System.out.println(hex);
		saveToImgFile(hex,"E://dd.jpg");
	}


	public static  void saveToImgFile(String src,String output){
		if(src==null||src.length()==0){
			return;
		}
		try{
			FileOutputStream out = new FileOutputStream(new File(output));
			byte[] bytes = src.getBytes();
			for(int i=0;i<bytes.length;i+=2){
				out.write(charToInt(bytes[i])*16+charToInt(bytes[i+1]));
			}
			out.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	private static int charToInt(byte ch){
		int val = 0;
		if(ch>=0x30&&ch<=0x39){
			val=ch-0x30;
		}else if(ch>=0x41&&ch<=0x46){
			val=ch-0x41+10;
		}
		return val;
	}
}