package jo.ko.rd.wataras_push.web;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import jo.ko.rd.wataras_push.Constants;
import jo.ko.rd.wataras_push.entity.HaisuiKikiJoho;
import jo.ko.rd.wataras_push.entity.HaisuiRecieveT;
import jo.ko.rd.wataras_push.entity.HojoM;
import jo.ko.rd.wataras_push.entity.KeiyakushaM;
import jo.ko.rd.wataras_push.entity.KyusuiKikiJoho;
import jo.ko.rd.wataras_push.entity.KyusuiRecieveT;
import jo.ko.rd.wataras_push.entity.SuiiKikiJoho;
import jo.ko.rd.wataras_push.entity.YusenSuiPairing;
import jo.ko.rd.wataras_push.service.PushService;

@Controller
public class PushController {

	@Autowired
	private PushService pushService;

	@Value("${wagri.api.token}")
	private String tokenUrl;

	@Value("${wagri.client.id}")
	private String client_id;

	@Value("${wagri.client.secret}")
	private String client_secret;

	@Value("${wagri.api.farmer}")
	private String farmerUrl;

	@Value("${wagri.api.hojo}")
	private String hojoUrl;

	@Value("${wagri.api.things}")
	private String thingsUrl;

	@Value("${wagri.api.sensors}")
	private String sensorsUrl;

	@Value("${wagri.api.observedProperties}")
	private String observedPropertiesUrl;

	@Value("${wagri.api.measurementUnits}")
	private String measurementUnitsUrl;

	@Value("${wagri.api.datastreams}")
	private String datastreamsUrl;

	@Value("${wagri.api.observations}")
	private String observationsUrl;

	@Value("${spring.profiles.active}")
	private String env;

	/** ロガー */
	private static final org.slf4j.Logger logger = LoggerFactory.getLogger(PushController.class);

	private static final String PROXY_HOST = "proxy.xx.xx.xx";
	private static final int PROXY_PORT = 3128;

	private Map<String, Object> token = null;
	private Instant startTime = null;
	private DateTimeFormatter dateTimeFormatterKey = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
	private DateTimeFormatter dateTimeFormatterTime = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");

	/**
	 * WAGRIへの連携バッチが一日に一回実行する
	 * @throws IOException
	 */
	@Scheduled(fixedRate = 1000 * 60 * 60 * 24)
	public void sendData() throws IOException {

		logger.info("---WAGRIへの送信バッチ実行開始---");

		// ほ場データ情報を読込み
		List<HojoM> hojoMList = pushService.getWagriTargetHojoMAll();

		// ほ場データ情報無しの場合
		if (hojoMList == null || hojoMList.size() == 0) {
			logger.info("---圃場情報なし---");
			// なにもしない
			return;
		}

		// センサー情報を登録
// 2020.01.30コメント追加 �Cセンサー
		sendSensorsJson();

// 2020.01.30コメント追加 �D測定項目
		// 測定項目情報を登録
		sendObservedPropertiesJson();

// 2020.01.30コメント追加 �E測定単位
		// 測定単位情報を登録
		sendUnitsJson();

		for (HojoM hojoM : hojoMList) {

			String keiyakushaId = hojoM.getKeiyakushaId();
			String chikuCd = hojoM.getChikuCd();
			String hojoCd = hojoM.getHojoCd();

// 2020.01.30コメント追加 �@農業従事者 sendFarmerData
			// WATARAS契約者情報を登録する
			sendFarmerData(keiyakushaId);

// 2020.01.30コメント追加 �A圃場 sendFieldData
			// WATARASほ場情報を登録する
			sendFieldData(keiyakushaId, chikuCd, hojoCd);

// 2020.01.30コメント追加 �Bセンサー群、�Fデータストリーム、�G測定結果
			// センサー（装置単位）
			// 給水機器情報登録
			pushKyusuiKikiData(chikuCd, keiyakushaId, hojoCd);

			// 排水機器情報登録
			pushHaisuiKikiData(chikuCd, keiyakushaId, hojoCd);

		}

		logger.info("---WAGRIへの送信バッチ実行終了---");
	}

	/**
	 * WAGRI APIにデータ送信する。
	 * @param apiUrl
	 * @param jsonBody
	 */
	private void sendWagriJson(String apiUrl, String jsonBody) {

		HttpURLConnection connection = null;
		String access_token = getToken();

		logger.info("【登録開始】" + "【登録URL】:" + apiUrl + "【登録情報】:" + jsonBody);
		try {

			URL url = new URL(apiUrl);
			if ("dev".equals(env)) {
				// Proxy
				Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(PROXY_HOST, PROXY_PORT));
				connection = (HttpURLConnection) url.openConnection(proxy);
			} else {
				connection = (HttpURLConnection) url.openConnection();
			}

			connection.setRequestMethod("POST");

			connection.setDoOutput(true);
			connection.setDoInput(true);
			connection.setUseCaches(false);
			// JSONで指定
			// APIの認証情報をヘーダに設定する
			connection.setRequestProperty("Content-Type", "application/json");
			connection.setRequestProperty("X-Authorization", access_token);

			connection.connect();
			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
			writer.write(jsonBody);
			writer.flush();
			writer.close();

			int responseCode = connection.getResponseCode();

			if (responseCode == HttpURLConnection.HTTP_CREATED) {
				// 通信(201)に成功したら
				logger.info("【登録成功】" + "登録情報:" + jsonBody);

			} else {
				// 失敗したら
				String line = null;
				String encoding = connection.getContentEncoding();
				if (null == encoding) {
					encoding = "UTF-8";
				}
				BufferedReader reader = new BufferedReader(
						new InputStreamReader(connection.getErrorStream(), encoding));
				StringBuffer errorMsg = new StringBuffer();
				// 1行ずつテキストを読み込む
				while ((line = reader.readLine()) != null) {
					errorMsg.append(line);
				}

				logger.info("【登録失敗】" + "エラーコード:" + responseCode + "エラーメッセージ:" + errorMsg);

			}
			connection.disconnect();
		} catch (IOException e) {
			// 自動生成された catch ブロック
			logger.info("【通信失敗】" + "登録情報:" + jsonBody);
			e.printStackTrace();
			if (connection != null) {
				// コネクションを切断
				connection.disconnect();
			}
		}

	}

	/**
	 * 給水装置送信
	 * @param chikuCd
	 * @param keiyakushaId
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void pushKyusuiKikiData(String chikuCd, String keiyakushaId, String hojoCd)
			throws JsonProcessingException {

		List<KyusuiKikiJoho> kyusuiKikiJohoList = pushService.getKyusuiKikiJoho(chikuCd, keiyakushaId, hojoCd);

		for (KyusuiKikiJoho kyusuiKikiJoho : kyusuiKikiJohoList) {

			// WATARASセンサー群(給水機器)情報登録
// 2020.01.30コメント追加 �Bセンサー群(給水機器) sendThingsData
			sendThingsData(kyusuiKikiJoho.getKikiCd(), kyusuiKikiJoho.getKikiName(),
					keiyakushaId + "_" + chikuCd + "_" + hojoCd, "給水機器");

			// �B有線水位計水位ペアリング情報取得
			YusenSuiPairing yusenSuiPairing = pushService.getYusenSuiPairing(kyusuiKikiJoho.getKikiCd());
			SuiiKikiJoho suiiKikiJoho = pushService.getSuiiKikiJoho(chikuCd, keiyakushaId, hojoCd,
					yusenSuiPairing.getSuiikeiKikiCd());

			// WATARASセンサー群(水位計)情報登録
// 2020.01.30コメント追加 �Bセンサー群(水位計) sendThingsData
			sendThingsData(suiiKikiJoho.getKikiCd(), suiiKikiJoho.getKikiName(),
					keiyakushaId + "_" + chikuCd + "_" + hojoCd, "水位計");

			String device = kyusuiKikiJoho.getKikiCd();
			KyusuiRecieveT kyusuiRecieveT = pushService.getkyusuiRecieveT(device);
			if (kyusuiRecieveT != null) {

				// 測定結果がNULLの場合、登録されない

				// 給水装置
				// 開度
				if (!StringUtils.isEmpty(kyusuiRecieveT.getTm7())) {
// 2020.01.30コメント追加 �Fデータストリーム(開度)、�G測定結果(開度)
					sendKaido(kyusuiKikiJoho, kyusuiRecieveT, hojoCd);
				}

				// バッテリー
				if (!StringUtils.isEmpty(kyusuiRecieveT.getTm2())) {
// 2020.01.30コメント追加 �Fデータストリーム(給水装置バッテリー)、�G測定結果(給水装置バッテリー)
					sendBattery(kyusuiKikiJoho, kyusuiRecieveT, hojoCd);
				}

				// 水位・水温計
				// 水位
				if (!StringUtils.isEmpty(kyusuiRecieveT.getTm9())) {
// 2020.01.30コメント追加 �Fデータストリーム(水位)、�G測定結果(水位)
					sendSuii(suiiKikiJoho, kyusuiRecieveT, hojoCd);
				}
				// 水温
				if (!StringUtils.isEmpty(kyusuiRecieveT.getTm10())) {
// 2020.01.30コメント追加 �Fデータストリーム(水温)、�G測定結果(水温)
					sendSuion(suiiKikiJoho, kyusuiRecieveT, hojoCd);
				}

			}
		}
	}

	/**
	 * 排水装置送信
	 * @param chikuCd
	 * @param keiyakushaId
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void pushHaisuiKikiData(String chikuCd, String keiyakushaId, String hojoCd)
			throws JsonProcessingException {

		List<HaisuiKikiJoho> haisuiKikiJohoList = pushService.getHaisuiKikiJoho(chikuCd, keiyakushaId, hojoCd);

		for (HaisuiKikiJoho haisuiKikiJoho : haisuiKikiJohoList) {

			// WATARASセンサー群(排水機器)情報登録
// 2020.01.30コメント追加 �Bセンサー群(排水機器) sendThingsData			
			sendThingsData(haisuiKikiJoho.getKikiCd(), haisuiKikiJoho.getKikiName(),
					keiyakushaId + "_" + chikuCd + "_" + hojoCd, "排水機器");

			String device = haisuiKikiJoho.getKikiCd();
			HaisuiRecieveT haisuiRecieveT = pushService.getHaisuiRecieveT(device);
			if (haisuiRecieveT != null) {

				// 排水装置
				// 排水高
				if (!StringUtils.isEmpty(haisuiRecieveT.getTm5())) {
// 2020.01.30コメント追加 �Fデータストリーム(排水高)、�G測定結果(排水高)
					sendHaisuiHeight(haisuiKikiJoho, haisuiRecieveT, hojoCd);
				}

				// バッテリー
				if (!StringUtils.isEmpty(haisuiRecieveT.getTm2())) {
// 2020.01.30コメント追加 �Fデータストリーム(排水装置バッテリー)、�G測定結果(排水装置バッテリー)
					sendBattery(haisuiKikiJoho, haisuiRecieveT, hojoCd);
				}

			}
		}
	}

	/**
	 * メタデータ
	 * @return
	 * @throws JsonProcessingException
	 */
	private List<LinkedHashMap<String, String>> getMetaJson() throws JsonProcessingException {

		LinkedHashMap<String, String> metaMap = new LinkedHashMap<String, String>();
		metaMap.put("encodingType", "application/pdf");
		List<LinkedHashMap<String, String>> metaMapList = new ArrayList<LinkedHashMap<String, String>>();
		metaMapList.add(metaMap);

		return metaMapList;
	}

	/**
	 * 給水装置の開度データを登録する
	 * @param kyusuiKikiJoho
	 * @param kyusuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendKaido(KyusuiKikiJoho kyusuiKikiJoho, KyusuiRecieveT kyusuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(開度) sendDatastreamsData
		sendDatastreamsData(kyusuiKikiJoho.getKikiCd() + "_" + "Valve",
				"Datastream_" + kyusuiKikiJoho.getKikiCd() + "_" + "Valve", kyusuiKikiJoho.getKikiName() + "_" + "開度",
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), "Valve", "Percent", "Kyuusui",
				kyusuiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(開度) sendResultData
		sendResultData(
				kyusuiKikiJoho.getKikiCd() + "_Valve" + "_" + kyusuiRecieveT.getAt().format(dateTimeFormatterKey),
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), kyusuiRecieveT.getTm7(),
				kyusuiKikiJoho.getKikiCd() + "_" + "Valve");

	}

	/**
	 * 給水装置のバッテリーデータを登録する
	 * @param kyusuiKikiJoho
	 * @param kyusuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendBattery(KyusuiKikiJoho kyusuiKikiJoho, KyusuiRecieveT kyusuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(給水装置バッテリー) sendDatastreamsData
		sendDatastreamsData(kyusuiKikiJoho.getKikiCd() + "_" + "Battery",
				"Datastream_" + kyusuiKikiJoho.getKikiCd() + "_" + "Battery", kyusuiKikiJoho.getKikiName() + "_" + "電圧",
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), "Battery", "Volt", "Kyuusui",
				kyusuiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(給水装置バッテリー) sendResultData				
		sendResultData(
				kyusuiKikiJoho.getKikiCd() + "_Battery" + "_" + kyusuiRecieveT.getAt().format(dateTimeFormatterKey),
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), kyusuiRecieveT.getTm2(),
				kyusuiKikiJoho.getKikiCd() + "_" + "Battery");

	}

	/**
	 * 水位水温計の水位データを登録する
	 * @throws JsonProcessingException
	 */
	private void sendSuii(SuiiKikiJoho suiiKikiJoho, KyusuiRecieveT kyusuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(水位) sendDatastreamsData				
		sendDatastreamsData(suiiKikiJoho.getKikiCd() + "_" + "Suii",
				"Datastream_" + suiiKikiJoho.getKikiCd() + "_" + "Suii", suiiKikiJoho.getKikiName() + "_" + "水位",
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), "Suii", "Centimeter", "Suii",
				suiiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(水位) sendResultData
		sendResultData(suiiKikiJoho.getKikiCd() + "_Suii" + "_" + kyusuiRecieveT.getAt().format(dateTimeFormatterKey),
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), kyusuiRecieveT.getTm9(),
				suiiKikiJoho.getKikiCd() + "_" + "Suii");

	}

	/**
	 * 水位水温計の水温データを登録する
	 * @param suiiKikiJoho
	 * @param kyusuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendSuion(SuiiKikiJoho suiiKikiJoho, KyusuiRecieveT kyusuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(水温) sendDatastreamsData				
		sendDatastreamsData(suiiKikiJoho.getKikiCd() + "_" + "Suion",
				"Datastream_" + suiiKikiJoho.getKikiCd() + "_" + "Suion", suiiKikiJoho.getKikiName() + "_" + "水温",
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), "Suion", "DegC", "Suii",
				suiiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(水温) sendResultData
		sendResultData(suiiKikiJoho.getKikiCd() + "_Suion" + "_" + kyusuiRecieveT.getAt().format(dateTimeFormatterKey),
				kyusuiRecieveT.getAt().format(dateTimeFormatterTime), kyusuiRecieveT.getTm10(),
				suiiKikiJoho.getKikiCd() + "_" + "Suion");

	}

	/**
	 * 排水装置の排水高データを登録する
	 * @param haisuiKikiJoho
	 * @param haisuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendHaisuiHeight(HaisuiKikiJoho haisuiKikiJoho, HaisuiRecieveT haisuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(排水高) sendDatastreamsData				
		sendDatastreamsData(haisuiKikiJoho.getKikiCd() + "_" + "Haisui",
				"Datastream_" + haisuiKikiJoho.getKikiCd() + "_" + "Haisui", haisuiKikiJoho.getKikiName() + "_" + "排水高",
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), "Haisui", "Centimeter", "Haisui",
				haisuiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(排水高) sendDatastreamsData				
		sendResultData(
				haisuiKikiJoho.getKikiCd() + "_Haisui" + "_" + haisuiRecieveT.getAt().format(dateTimeFormatterKey),
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), haisuiRecieveT.getTm5(),
				haisuiKikiJoho.getKikiCd() + "_" + "Haisui");

	}

	/**
	 * 排水装置のバッテリーデータを登録する
	 * @param haisuiKikiJoho
	 * @param haisuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendBattery(HaisuiKikiJoho haisuiKikiJoho, HaisuiRecieveT haisuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
// 2020.01.30コメント追加 �Fデータストリーム(排水装置バッテリー) sendDatastreamsData
		sendDatastreamsData(haisuiKikiJoho.getKikiCd() + "_" + "Battery",
				"Datastream_" + haisuiKikiJoho.getKikiCd() + "_" + "Battery", haisuiKikiJoho.getKikiName() + "_" + "電圧",
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), "Battery", "Volt", "Haisui",
				haisuiKikiJoho.getKikiCd());

		// 測定結果登録
// 2020.01.30コメント追加 �G測定結果登録(排水装置バッテリー) sendDatastreamsData				
		sendResultData(
				haisuiKikiJoho.getKikiCd() + "_Battery" + "_" + haisuiRecieveT.getAt().format(dateTimeFormatterKey),
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), haisuiRecieveT.getTm2(),
				haisuiKikiJoho.getKikiCd() + "_" + "Battery");

	}

	/**
	 * 水位水温計の水位データを登録する
	 * @throws JsonProcessingException
	 */
	private void sendSuii(SuiiKikiJoho suiiKikiJoho, HaisuiRecieveT haisuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
		sendDatastreamsData(suiiKikiJoho.getKikiCd() + "_" + "Suii",
				"Datastream_" + suiiKikiJoho.getKikiCd() + "_" + "Suii", suiiKikiJoho.getKikiName() + "_" + "水位",
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), "Suii", "Centimeter", "Suii",
				suiiKikiJoho.getKikiCd());

		// 測定結果登録
		sendResultData(suiiKikiJoho.getKikiCd() + "_Suii" + "_" + haisuiRecieveT.getAt().format(dateTimeFormatterKey),
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), haisuiRecieveT.getTm9(),
				suiiKikiJoho.getKikiCd() + "_" + "Suii");
	}

	/**
	 * 水位水温計の水温データを登録する
	 * @param suiiKikiJoho
	 * @param kyusuiRecieveT
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendSuion(SuiiKikiJoho suiiKikiJoho, HaisuiRecieveT haisuiRecieveT, String hojoCd)
			throws JsonProcessingException {

		// データストリーム情報登録
		sendDatastreamsData(suiiKikiJoho.getKikiCd() + "_" + "Suion",
				"Datastream_" + suiiKikiJoho.getKikiCd() + "_" + "Suion", suiiKikiJoho.getKikiName() + "_" + "水温",
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), "Suion", "DegC", "Suii",
				suiiKikiJoho.getKikiCd());

		// 測定結果登録
		sendResultData(suiiKikiJoho.getKikiCd() + "_Suion" + "_" + haisuiRecieveT.getAt().format(dateTimeFormatterKey),
				haisuiRecieveT.getAt().format(dateTimeFormatterTime), haisuiRecieveT.getTm10(),
				suiiKikiJoho.getKikiCd() + "_" + "Suion");

	}

	/**
	 * 農業従事者(契約者)を登録する
	 * @param keiyakushaId
	 * @throws JsonProcessingException
	 */
	private void sendFarmerData(String keiyakushaId) throws JsonProcessingException {
		ObjectMapper mapper = new ObjectMapper();
		String json = "";
		// WATARAS契約者情報取得取得
		KeiyakushaM wagriTargetKeiyakushaM = pushService.getWagriTargetKeiyakushaMByPk(keiyakushaId);

		if (wagriTargetKeiyakushaM != null) {
			LinkedHashMap<String, String> keiyakushainfoMap = new LinkedHashMap<String, String>();
			keiyakushainfoMap.put(Constants.JSON_KEY_FARMER_ID, wagriTargetKeiyakushaM.getKeiyakushaId());
			keiyakushainfoMap.put(Constants.JSON_KEY_FARMER_NAME, wagriTargetKeiyakushaM.getKeiyakushaName());

			// WAGRIAPI契約者情報登録
			json = mapper.writeValueAsString(keiyakushainfoMap);
			sendWagriJson(farmerUrl, json);
		}
	}

	/**
	 * 圃場を登録する
	 * @param keiyakushaId
	 * @param chikuCd
	 * @param hojoCd
	 * @throws JsonProcessingException
	 */
	private void sendFieldData(String keiyakushaId, String chikuCd, String hojoCd) throws JsonProcessingException {
		ObjectMapper mapper = new ObjectMapper();
		String json = "";
		// WATARASほ場情報取得
		HojoM wagriTargetHojoM = pushService.getHojoMByPk(keiyakushaId, chikuCd, hojoCd);
		if (wagriTargetHojoM != null) {
			LinkedHashMap<String, Object> hojoinfoMap = new LinkedHashMap<>();
			hojoinfoMap.put(Constants.JSON_KEY_FIELD_ID, keiyakushaId + "_" + chikuCd + "_" + hojoCd);
			hojoinfoMap.put(Constants.JSON_KEY_FARMER_ID, wagriTargetHojoM.getKeiyakushaId());
			hojoinfoMap.put(Constants.JSON_KEY_LOCATION_1, wagriTargetHojoM.getChikuName());
			hojoinfoMap.put(Constants.JSON_KEY_LOCATION_2, wagriTargetHojoM.getChikuName());
			hojoinfoMap.put(Constants.JSON_KEY_LOCATION_3, wagriTargetHojoM.getChikuName());

			hojoinfoMap.put(Constants.JSON_KEY_SOIL_CODE, "");

			if (wagriTargetHojoM.getIdo() != null) {
				hojoinfoMap.put(Constants.JSON_KEY_LATITUDE, wagriTargetHojoM.getIdo());
			}
			if (wagriTargetHojoM.getKeido() != null) {
				hojoinfoMap.put(Constants.JSON_KEY_LONGITUDE, wagriTargetHojoM.getKeido());
			}

			// WATARASほ場情報登録
			json = mapper.writeValueAsString(hojoinfoMap);
			sendWagriJson(hojoUrl, json);

		}
	}

	/**
	 * 給水装置、排水装置、水位・水温計などのセンサーを登録する
	 * @throws JsonProcessingException
	 */
	private void sendSensorsJson() throws JsonProcessingException {

// 2020.01.30コメント追加 �Cセンサー（給水機器）sendSensorsData
		// センサー（給水機器）情報登録
		sendSensorsData("Kyuusui", "Sensor of Kyuusui", "給水装置");

// 2020.01.30コメント追加 �Cセンサー（排水装置）sendSensorsData
		// センサー（排水機器）情報登録
		sendSensorsData("Haisui", "Sensor of Haisui", "排水装置");

// 2020.01.30コメント追加 �Cセンサー（水位・水温計）sendSensorsData
		// センサー（水位・水温計）情報登録
		sendSensorsData("Suii", "Sensor of Suii", "水位・水温計");
	}

	/**
	 * センサーを登録する
	 * @param key
	 * @param name
	 * @param description
	 * @throws JsonProcessingException
	 */
	private void sendSensorsData(String key, String name, String description) throws JsonProcessingException {
		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();

		List<LinkedHashMap<String, String>> metaJsonList = getMetaJson();

		String json = "";

		// センサー（給水機器）情報取得
		LinkedHashMap<String, Object> sensorsInfoMap = new LinkedHashMap<>();
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_KEY, key);
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_NAME, name);
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_DESCRIPTION, description);
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_MANUFACTURER, "");
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_PRODUCTNAME, "");
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_MODELNUMBER, "");
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_MANUFACTURER_MAILADDRESS, "");
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_MANUFACTURER_ADDRESS, "");
		sensorsInfoMap.put(Constants.JSON_KEY_SENSORS_METADATA, metaJsonList);

		// センサー（給水機器）情報登録
		json = mapper.writeValueAsString(sensorsInfoMap);
		sendWagriJson(sensorsUrl, json);
	}

	/**
	 * 水位、水温、開度、排水高、電圧などの測定項目を登録する
	 * @throws JsonProcessingException
	 */
	private void sendObservedPropertiesJson() throws JsonProcessingException {

// 2020.01.30コメント追加 �D測定項目(水位) sendObservedPropertiesData
		// 測定項目（水位）情報登録
		sendObservedPropertiesData("Suii", "ObservedProperty Suii", "水位");

// 2020.01.30コメント追加 �D測定項目(水温) sendObservedPropertiesData
		// 測定項目（水温）情報登録
		sendObservedPropertiesData("Suion", "ObservedProperty Suion", "水温");

// 2020.01.30コメント追加 �D測定項目(開度) sendObservedPropertiesData
		// 測定項目（開度）情報登録
		sendObservedPropertiesData("Valve", "ObservedProperty Valve", "開度");

// 2020.01.30コメント追加 �D測定項目(排水高) sendObservedPropertiesData
		// 測定項目（排水高）情報登録
		sendObservedPropertiesData("Haisui", "ObservedProperty Haisui", "排水高");

// 2020.01.30コメント追加 �D測定項目(電圧) sendObservedPropertiesData
		// 測定項目（電圧）情報登録
		sendObservedPropertiesData("Battery", "ObservedProperty Battery", "電圧");
	}

	/**
	 * 測定項目を登録する
	 * @param key
	 * @param name
	 * @param discription
	 * @throws JsonProcessingException
	 */
	private void sendObservedPropertiesData(String key, String name, String discription)
			throws JsonProcessingException {
		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();
		String json = "";
		// 測定項目情報取得
		LinkedHashMap<String, String> opMap = new LinkedHashMap<String, String>();
		opMap.put(Constants.JSON_KEY_OP_KEY, key);
		opMap.put(Constants.JSON_KEY_OP_NAME, name);
		opMap.put(Constants.JSON_KEY_OP_DESCRIPTION, discription);
		opMap.put(Constants.JSON_KEY_OP_DEFINITION, "");
		json = mapper.writeValueAsString(opMap);
		// 測定項目情報登録
		sendWagriJson(observedPropertiesUrl, json);
	}

	/**
	 * 水位、水温、開度、排水高、電圧などの測定単位を登録する
	 * @throws JsonProcessingException
	 */
	private void sendUnitsJson() throws JsonProcessingException {

// 2020.01.30コメント追加 �E測定単位（cm）sendUnitsData
		// 測定単位（cm）情報登録
		sendUnitsData("Centimeter", "Unit Centimeter", "cm");

// 2020.01.30コメント追加 �E測定単位（℃）sendUnitsData
		// 測定単位（℃）情報登録
		sendUnitsData("DegC", "Unit DegC", "℃");

// 2020.01.30コメント追加 �E測定単位（%）sendUnitsData
		// 測定単位（%）情報登録
		sendUnitsData("Percent", "Unit Percent", "%");

// 2020.01.30コメント追加 �E測定単位（V）sendUnitsData
		// 測定単位（V）情報登録
		sendUnitsData("Volt", "Unit Volt", "V");

	}

	/**
	 * 測定単位を登録する
	 * @param key
	 * @param name
	 * @param discription
	 * @throws JsonProcessingException
	 */
	private void sendUnitsData(String key, String name, String discription) throws JsonProcessingException {
		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();
		String json = "";
		// 測定単位情報取得
		LinkedHashMap<String, String> muMap = new LinkedHashMap<String, String>();
		muMap.put(Constants.JSON_KEY_MU_KEY, key);
		muMap.put(Constants.JSON_KEY_MU_NAME, name);
		muMap.put(Constants.JSON_KEY_MU_DESCRIPTION, discription);
		muMap.put(Constants.JSON_KEY_MU_URI, "");
		json = mapper.writeValueAsString(muMap);
		// 測定単位情報登録
		sendWagriJson(measurementUnitsUrl, json);
	}

	/**
	 * センサー群を登録する
	 * @param key
	 * @param name
	 * @param fieldId
	 * @param kiki
	 * @throws JsonProcessingException
	 */
	private void sendThingsData(String key, String name, String fieldId, String kiki) throws JsonProcessingException {
		String json = "";
		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();

		// WATARASセンサー群情報取得
		LinkedHashMap<String, Object> thingInfoMap = new LinkedHashMap<>();
		thingInfoMap.put(Constants.JSON_KEY_THINGS_KEY, key);
		thingInfoMap.put(Constants.JSON_KEY_THINGS_NAME, name);
		thingInfoMap.put(Constants.JSON_KEY_THINGS_DESCRIPTION, name + "_" + kiki + "_" + key);
		thingInfoMap.put(Constants.JSON_KEY_THINGS_FIELD_ID, fieldId);
		thingInfoMap.put(Constants.JSON_KEY_THINGS_PROPERTIES, new HashMap<String, String>());
		json = mapper.writeValueAsString(thingInfoMap);
		// WATARASセンサー群情報登録
		sendWagriJson(thingsUrl, json);
	}

	/**
	 * データストリームを登録する
	 * @param key
	 * @param name
	 * @param time
	 * @param observedPropertyId
	 * @param unitOfMeasurementId
	 * @param sensorId
	 * @param thingId
	 * @throws JsonProcessingException
	 */
	private void sendDatastreamsData(String key, String name, String description, String time,
			String observedPropertyId,
			String unitOfMeasurementId, String sensorId, String thingId) throws JsonProcessingException {
		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();
		String json = "";

		// データストリーム情報取得
		LinkedHashMap<String, String> dsMap = new LinkedHashMap<String, String>();
		dsMap.put(Constants.JSON_KEY_DS_KEY, key);
		dsMap.put(Constants.JSON_KEY_DS_NAME, name);
		dsMap.put(Constants.JSON_KEY_DS_DESCRIPTION, description);
		dsMap.put(Constants.JSON_KEY_DS_OBSERVED_AREA, "");
		dsMap.put(Constants.JSON_KEY_DS_PHENOMENON_TIME, time);
		dsMap.put(Constants.JSON_KEY_DS_RESULT_TIME, time);
		// 測定項目のkey
		dsMap.put(Constants.JSON_KEY_DS_OBSERVEDPROPERTY_ID, observedPropertyId);
		// 測定単位のkey
		dsMap.put(Constants.JSON_KEY_DS_UNITOFMEASUREMENT_ID, unitOfMeasurementId);
		// センサーのkey
		dsMap.put(Constants.JSON_KEY_DS_SENSOR_ID, sensorId);
		dsMap.put(Constants.JSON_KEY_DS_OBSERRVATIONCONDITION_ID, null);
		dsMap.put(Constants.JSON_KEY_DS_THING_ID, thingId);

		json = mapper.writeValueAsString(dsMap);
		// データストリーム情報登録
		sendWagriJson(datastreamsUrl, json);
	}

	/**
	 * 測定結果を登録する
	 * @param key
	 * @param time
	 * @param result
	 * @param datastreamId
	 * @throws JsonProcessingException
	 */
	private void sendResultData(String key, String time, String result, String datastreamId)
			throws JsonProcessingException {

		// json読込みマッパー
		ObjectMapper mapper = new ObjectMapper();
		String json = "";

		LinkedHashMap<String, String> resultJsonMap = new LinkedHashMap<String, String>();
		resultJsonMap.put("key", key);
		resultJsonMap.put("phenomenonTime", time);
		resultJsonMap.put("phenomenonEndTime", null);
		resultJsonMap.put("resultTime", null);
		resultJsonMap.put("result", result);
		resultJsonMap.put("DatastreamId", datastreamId);
		resultJsonMap.put("FeatureOfInterestId", null);
		json = mapper.writeValueAsString(resultJsonMap);
		// 測定結果-開度情報登録
		sendWagriJson(observationsUrl, json);
	}

	/**
	 * WAGRI APIのアクセストークンを取得する
	 * @return
	 */
	private String getToken() {

		boolean invalidFlg = true;

		// アクセストークンが無効になるかどうかを判断する
		if (startTime != null && token != null) {
			long timeBetween = ChronoUnit.SECONDS.between(startTime, Instant.now());
			Integer tokenTime = (Integer) token.get("expires_in");
			invalidFlg = timeBetween > tokenTime.longValue();
		}

		HttpURLConnection connection = null;
		String body = "grant_type=client_credentials&client_id=" + client_id + "&client_secret=" + client_secret;
		StringBuffer result = new StringBuffer();
		ObjectMapper mapper = new ObjectMapper();

		if (token == null || invalidFlg) {
			try {
				startTime = Instant.now();
				URL url = new URL(tokenUrl);
				if ("dev".equals(env)) {
					// Proxy
					Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(PROXY_HOST, PROXY_PORT));
					connection = (HttpURLConnection) url.openConnection(proxy);
				} else {
					connection = (HttpURLConnection) url.openConnection();
				}

				connection.setRequestMethod("GET");

				connection.setDoOutput(true);
				connection.setDoInput(true);
				connection.setUseCaches(false);
				connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
				connection.connect();

				BufferedWriter writer = new BufferedWriter(
						new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
				writer.write(body);
				writer.flush();
				writer.close();

				int responseCode = connection.getResponseCode();

				if (responseCode == HttpURLConnection.HTTP_OK) {
					// 通信(200)に成功したら
					String encoding = connection.getContentEncoding();
					if (null == encoding) {
						encoding = "UTF-8";
					}
					InputStream inputStream = connection.getInputStream();
					BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, encoding));
					String line = null;
					// 1行ずつテキストを読み込む
					while ((line = reader.readLine()) != null) {
						result.append(line);
					}

					logger.info("【認証トークン取得成功】認証トークン:" + result);

					token = mapper.readValue(result.toString(), Map.class);

				} else {
					// 失敗したら
					String line = null;
					String encoding = connection.getContentEncoding();
					if (null == encoding) {
						encoding = "UTF-8";
					}
					BufferedReader reader = new BufferedReader(
							new InputStreamReader(connection.getErrorStream(), encoding));
					StringBuffer errorMsg = new StringBuffer();
					// 1行ずつテキストを読み込む
					while ((line = reader.readLine()) != null) {
						errorMsg.append(line);
					}

					logger.info("【認証トークン取得失敗】" + "エラーコード:" + responseCode + "エラーメッセージ:" + errorMsg);

				}

				connection.disconnect();
			} catch (IOException e) {
				// 自動生成された catch ブロック
				logger.info("【認証トークン取得失敗】" + "情報:" + body);
				e.printStackTrace();
				if (connection != null) {
					// コネクションを切断
					connection.disconnect();
				}
			}
		}
		return token != null ? (String) token.get("access_token") : "";
	}

}