package com.examples.android.healthcare.functions;

import android.util.Log;

import com.examples.android.healthcare.BuildConfig;

import java.util.function.BiConsumer;

public class MyLogging {

    @FunctionalInterface
    public interface LogParamsConsumer<S, S1, T> {
        public void print(String tag, String format, Object... params);
    }

    // DEBUG Log Function
    public static BiConsumer<String, String> DEBUG_OUT = (tag, output) -> {
        if (BuildConfig.DEBUG) { //■■ デバックビルドならDEBUGログを出力 ※リリースビルドなら出力されない ■■
            Log.d(tag, output);
        }
    };
    // DEBUG Log Function
    public LogParamsConsumer<String, String, Object[]> DEBUG_OUT_PARAMS = (tag, format, params) -> {
        if (BuildConfig.DEBUG) {
            String output = String.format(format, params);
            Log.d(tag, output);
        }
    };

}

package com.examples.android.healthcare.tasks;


import com.examples.android.healthcare.data.ResponseStatus;

public abstract class Result<T> {
    private Result() {
    }

    public static final class Success<T> extends Result<T> {
        private final T data;

        public Success(T data) {
            this.data = data;
        }

        public T get() {return data; }
    }

    public static final class Warning<T> extends Result<T> {
        private final ResponseStatus status;

        public Warning(ResponseStatus status) {
            this.status = status;
        }

        public ResponseStatus getResponseStatus() { return status; }
    }

    public static final class Error<T> extends Result<T> {
        private final Exception exception;

        public Error(Exception exception) {
            this.exception = exception;
        }

        public Exception getException() { return exception; }
    }
}

package com.examples.android.healthcare.tasks;

public interface RepositoryCallback<T> {
    void onComplete(Result<T> result);
}

package com.examples.android.healthcare.tasks;

import android.os.Handler; // Android依存クラス ※Java環境ではスタブを参照
import android.util.Log;   // 同上

import com.google.gson.JsonParseException;
import com.examples.android.healthcare.data.GetCurrentDataResult;
import com.examples.android.healthcare.data.RegisterResult;
import com.examples.android.healthcare.data.ResponseStatus;

import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ExecutorService;

import static com.examples.android.healthcare.functions.MyLogging.DEBUG_OUT;

/**
 * HTTPリクエスト実行リポジトリクラス
 * @param <T> レスポンス用Javaクラス
 */
public abstract class HealthcareRepository<T> {
    private static final String TAG = "HealthcareRepository";

    public HealthcareRepository() {}

    /**
     * GETリクエスト生成メソッド
     * @param pathIdx パス用インデックス ※サブクラスで複数のGETリクエストパス定義
     * @param baseUrl パスを含まないURL (Wifi | Mobile)
     * @param requestParameter リクエストパラメータ
     * @param headers リクエストヘッダー
     * @param executor スレッドエクゼキューター
     * @param handler Android Handlerオブジェクト
     * @param callback Activity(Fragment)が結果を受け取るコールバック
     */
    public void makeGetRequest(
            int pathIdx,
            String baseUrl,
            String requestParameter,
            Map<String, String> headers,
            ExecutorService executor,
            Handler handler,
            final RepositoryCallback<T> callback) {
        executor.execute(() -> {
            try {
                String requestUrl = baseUrl + getRequestPath(pathIdx) + requestParameter;
                Result<T> result =
                        getRequest(requestUrl, headers);
                // 200, 4xx - 50x系
                notifyResult(result, callback, handler);
            } catch (Exception e) {
                // サーバー側のレスポンスBUGか, Android側のBUG想定
                Result<T> errorResult = new Result.Error<>(e);
                notifyResult(errorResult, callback, handler);
            }
        });
    }

    /**
     * POSTリクエスト(登録・更新)生成メソッド
     * @param pathIdx パス用インデックス ※サブクラスで複数のGETリクエストパス定義
     * @param baseUrl パスを含まないURL (Wifi | Mobile)
     * @param headers リクエストヘッダー
     * @param executor スレッドエクゼキューター
     * @param handler Android Handlerオブジェクト
     * @param callback Activity(Fragment)が結果を受け取るコールバック
     */
    public void makeRegisterRequest(
            int pathIdx,
            String baseUrl,
            String jsonData,
            Map<String, String> headers,
            ExecutorService executor,
            Handler handler,
            final RepositoryCallback<T> callback) {
        executor.execute(() -> {
            try {
                String requestUrl = baseUrl + getRequestPath(pathIdx);
                Result<T> result =
                        postRegisterDataRequest(requestUrl, headers, jsonData);
                notifyResult(result, callback, handler);
            } catch (Exception e) {
                Result<T> errorResult = new Result.Error<>(e);
                notifyResult(errorResult, callback, handler);
            }
        });
    }

    /**
     * GETリクエスト実行メソッド
     * @param requestUrl リクエストURL
     * @param requestHeaders リクエストヘッダー
     * @return サーバーからのレスポンスを対応するクラスのオブジェクト
     */
    private Result<T> getRequest(
            String requestUrl, Map<String, String> requestHeaders) {
        HttpURLConnection conn = null;
        try {
            URL url = new URL(requestUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Accept", "application/json;");
            for (String key : requestHeaders.keySet()) {
                conn.setRequestProperty(key, requestHeaders.get(key));
            }

            // Check response code: allow 200 only.
            int respCode = conn.getResponseCode();
            DEBUG_OUT.accept(TAG, "ResponseCode:" + respCode);
            if (respCode == HttpURLConnection.HTTP_OK) {
                String respText = getResponseText(conn.getInputStream());
                T result = parseResultJson(respText);
                return new Result.Success<>(result);
            } else {
                // 4xx - 50x
                // Flaskアプリからはエラーストリームが生成される
                String respText = getResponseText(conn.getErrorStream());
                DEBUG_OUT.accept(TAG, "NG: " + respText);
                // ウォーニング時のJSONはデータ部が存在しないのでウォーニング専用ハースを実行
                T result = parseWarningJson(respText);
                // ResponseStatusのみ, GET用Dataクラス == null
                ResponseStatus status = ((GetCurrentDataResult) result).getStatus();
                DEBUG_OUT.accept(TAG, "NG.ResponseStatus: " + respText);
                return new Result.Warning<>(status);
            }
        } catch (Exception ie) {
            Log.w(TAG, ie.getLocalizedMessage());
            return new Result.Error<>(ie);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }

    /**
     * POSTリクエスト(登録・更新)実行メソッド
     * @param requestUrl リクエストURL
     * @param requestHeaders リクエストヘッダー
     * @param jsonData JSONデータ(文字列)
     * @return サーバーからのレスポンスを対応するクラスのオブジェクト
     */
    private Result<T> postRegisterDataRequest(
            String requestUrl, Map<String, String> requestHeaders, String jsonData) {
        HttpURLConnection conn = null;
        try {
            URL url = new URL(requestUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Accept", "application/json;");
            // POSTデータ有り(JSON)
            conn.setDoOutput(true);
            // レスポンス有り
            conn.setDoInput(true);
            conn.setChunkedStreamingMode(0);
            // ヘッダー設定
            for (String key : requestHeaders.keySet()) {
                conn.setRequestProperty(key, requestHeaders.get(key));
            }
            // リクエストデータ用出力ストリーム
            OutputStream output = new BufferedOutputStream(conn.getOutputStream());
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(output, StandardCharsets.UTF_8));
            writer.write(jsonData);
            writer.flush();

            // Check response code: allow 200 only.
            int respCode = conn.getResponseCode();
            DEBUG_OUT.accept(TAG, "ResponseCode:" + respCode);
            if (respCode == HttpURLConnection.HTTP_OK) {
                String respText = getResponseText(conn.getInputStream());
                T result = parseResultJson(respText);
                return new Result.Success<>(result);
            } else {
                // 4xx - 50x: ResultStatus, Dataクラス == null
                // Flaskアプリからはエラーストリームが生成される
                String respText = getResponseText(conn.getErrorStream());
                DEBUG_OUT.accept(TAG, "NG: " + respText);
                // ウォーニング時のJSONはデータ部が存在しないのでウォーニング専用ハースを実行
                T result = parseWarningJson(respText);
                // ResponseStatusのみ, Post用Dataクラス == null
                ResponseStatus status = ((RegisterResult) result).getStatus();
                DEBUG_OUT.accept(TAG, "NG.ResponseStatus: " + respText);
                return new Result.Warning<>(status);
            }
        } catch (Exception ie) {
            // パースエラーまたはIO例外
            Log.w(TAG, ie.getLocalizedMessage());
            return new Result.Error<>(ie);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }

    /**
     * UI側のコールバックに結果(Javaオブジェクト)をセットする
     * @param result レスポンスオブジェクト
     * @param callback UI側コールバック
     * @param handler Androidハンドラー
     */
    private void notifyResult(final Result<T> result,
                              final RepositoryCallback<T> callback,
                              final Handler handler) {
        handler.post(() -> callback.onComplete(result));
    }

    /**
     *
     * @param pathIdx パスインデックス (1 - m)
     * @return サブクラスが提供するパス
     */
    public abstract String getRequestPath(int pathIdx);

    /**
     * 入力ストリームからJSON文字列を取得
     * @param is 入力ストリーム
     * @return JSON文字列
     * @throws IOException IO例外
     */
    public abstract String getResponseText(InputStream is) throws IOException;

    /**
     * HTTP 200(OK) レスポンス時のJSON文字列をパースしてJavaオブジェクトを生成
     * @param jsonText JSON文字列を
     * @return サブグラスが定義するJavaオブジェクトを生成
     * @throws JsonParseException GSONのパース例外
     */
    public abstract T parseResultJson(String jsonText) throws JsonParseException;

    /**
     * HTTP 4xx, 50x系レスポンス時のJSON文字列をパースしてJavaオブジェクトを生成
     * @param jsonText ウォーニング用JSON文字列
     * @return サブグラスが定義するウォーニング用Javaオブジェクトを生成
     * @throws JsonParseException GSONのパース例外
     */
    public abstract T parseWarningJson(String jsonText) throws JsonParseException;
}

public class LoginRepository {
    // ...

    public void makeLoginRequest(
        final String jsonBody,
        final RepositoryCallback<LoginResponse> callback,
        final Handler resultHandler,
    ) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Result<LoginResponse> result = makeSynchronousLoginRequest(jsonBody);
                    notifyResult(result, callback, resultHandler);
                } catch (Exception e) {
                    Result<LoginResponse> errorResult = new Result.Error<>(e);
                    notifyResult(errorResult, callback, resultHandler);
                }
            }
        });
    }

    private void notifyResult(
        final Result<LoginResponse> result,
        final RepositoryCallback<LoginResponse> callback,
        final Handler resultHandler
    ) {
        resultHandler.post(new Runnable() {
            @Override
            public void run() {
                callback.onComplete(result);
            }
        });
    }
}

package com.examples.android.healthcare.tasks;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParseException;
import com.examples.android.healthcare.data.RegisterResult;
import com.examples.android.healthcare.data.ResponseStatus;
import com.examples.android.healthcare.data.ResponseWarningStatus;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * AppTopFragment用データ登録(更新)リポジトリクラス
 */
public class ResisterDataRepository extends HealthcareRepository<RegisterResult> {
    // パス配列: 登録時, 更新時
    private static final String[] URL_PATHS = {"/register", "/update"};

    public ResisterDataRepository() {}

    @Override
    public String getRequestPath(int pathIdx) {
        return URL_PATHS[pathIdx];
    }

    @Override
    public String getResponseText(InputStream is) throws IOException {
        StringBuilder sb;
        try (BufferedReader bf = new BufferedReader
                (new InputStreamReader(is, StandardCharsets.UTF_8))) {
            String line;
            sb = new StringBuilder();
            while ((line = bf.readLine()) != null) {
                sb.append(line);
            }
        }
        return sb.toString();
    }

    /**
     * 正常時のレスポンスオブジェクトを取得する
     * <pre>HTTP OK時にサーバーが返却するレスポンス例
     {"data": {"emailAddress": "user1@example.com", "measurementDay": "2023-02-13"},
      "status": {"code": 0, "message": "OK"}}
     * </pre>
     * @param jsonText JSON文字列
     * @return レスポンスオブジェクト
     * @throws JsonParseException パース例外
     */
    @Override
    public RegisterResult parseResultJson(String jsonText) throws JsonParseException {
        Gson gson = new Gson();
        return gson.fromJson(jsonText, RegisterResult.class);
    }

    /**
     * ウォーニング時のレスポンスオブジェクトを取得する
     * <pre>ウォーニング時にサーバーが返却するレスポンス例
     {"status": {"code": 400,"message": "461,User is not found."}}
     * </pre>
     * @param jsonText ウォーニング用JSON文字列
     * @return レスポンスオブジェクト<br/>
     *   ResponseStatusオブジェクトのみがセットされDataオブジェクトはnullがセットされる
     * @throws JsonParseException パース例外
     */
    @Override
    public RegisterResult parseWarningJson(String jsonText) throws JsonParseException {
        Gson gson = new GsonBuilder().serializeNulls().create();
        // ResponseStatusに"status"タグ含めたResponseStatusのラップクラス
        // {"status": {"code": 400,"message": "461,User is not found."}}部分を受取るクラス
        ResponseWarningStatus warningStatus = gson.fromJson(jsonText, ResponseWarningStatus.class);
        // {"code": 400,"message": "461,User is not found."} 部分を受取るクラス
        ResponseStatus status = warningStatus.getStatus();
        return new RegisterResult(null, status);
    }
}

package com.examples.android.healthcare.tasks;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParseException;
import com.examples.android.healthcare.data.GetCurrentDataResult;
import com.examples.android.healthcare.data.ResponseStatus;
import com.examples.android.healthcare.data.ResponseWarningStatus;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * AppTopFragment用登録済みデータ取得リポジトリクラス
 */
public class GetCurrentDataRepository extends HealthcareRepository<GetCurrentDataResult> {
    // GETリクエストパス
    private static final String URL_PATH = "/getcurrentdata";

    @Override
    public String getRequestPath(int pathIdx) {
        return URL_PATH;
    }

    @Override
    public String getResponseText(InputStream is) throws IOException {
        StringBuilder sb;
        try (BufferedReader bf = new BufferedReader
                (new InputStreamReader(is, StandardCharsets.UTF_8))) {
            String line;
            sb = new StringBuilder();
            while ((line = bf.readLine()) != null) {
                sb.append(line);
            }
        }
        return sb.toString();
    }

    /**
     * 登録済みデータオブジェクトを取得する
     * <pre>HTTP OK時にサーバーが返却するレスポンス例 ※一部省略
     {"data": {"emailAddress": "sapporo@examples.com", "healthcareData": {  "bloodPressure": {
     "eveningMax": 124, "eveningMeasurementTime": "22:20", "eveningMin": 72, "eveningPulseRate": 59,
     "morningMax": 112, "morningMeasurementTime": "06:45", "morningMin": 67, "morningPulseRate": 65 },
     ...一部省略...
     },"walkingCount": {counts": 8576}},
     "measurementDay": "2023-02-01",
     "weatherData": {"weatherCondition": {"condition": "曇りのち雪"}}},
     "status": {"code": 0, "message": "OK"}}
     * </pre>
     * @param jsonText JSON文字列を
     * @return 登録済みデータオブジェクト
     * @throws JsonParseException パース例外
     */
    @Override
    public GetCurrentDataResult parseResultJson(String jsonText) throws JsonParseException {
        Gson gson = new Gson();
        return gson.fromJson(jsonText, GetCurrentDataResult.class);
    }

    /**
     * ウォーニング時のレスポンスオブジェクトを取得する
     * <pre>ウォーニング時にサーバーが返却するレスポンス例
     {"status": {"code": 400,"message": "461,User is not found."}}
     * </pre>
     * @param jsonText ウォーニング用JSON文字列
     * @return レスポンスオブジェクト<br/>
     *   ResponseStatusオブジェクトのみがセットされDataオブジェクトはnullがセットされる
     * @throws JsonParseException パース例外
     */
    @Override
    public GetCurrentDataResult parseWarningJson(String jsonText) throws JsonParseException {
        Gson gson = new GsonBuilder().serializeNulls().create();
        ResponseWarningStatus warningStatus = gson.fromJson(jsonText, ResponseWarningStatus.class);
        ResponseStatus status = warningStatus.getStatus();
        return new GetCurrentDataResult(null, status);
    }
}

package com.examples.android.healthcare;

import android.app.Application;          // スタブ
import android.content.res.AssetManager; // スタブ
import android.os.Handler;               // スタブ
import android.util.Log;                 // スタブ
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;

import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Type;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static com.examples.android.healthcare.functions.MyLogging.DEBUG_OUT;

public class HealthcareApplication extends Application {
    private static final String LOG_TAG = "HealthcareApplication";
    // Json file in assets for request.
    private static final String REQUEST_INFO_FILE = "request_info.json";
    private Map<String, String> mRequestUrls;
    private Map<String, String> mRequestHeaders;

    public ExecutorService mEexecutor = Executors.newFixedThreadPool(1);
    // Handerだけは Androidとは異なりダミーのコンストラクタで代用 ※何の処理もしないクラス
    public Handler mHandler = new Handler();
    // ■■ Androidアプリのプロジェクトにコピーするときには下記コードに置き換える必要がある
    // public Handler mHandler = HandlerCompat.createAsync(Looper.getMainLooper());

    @Override
    public void onCreate() {
        super.onCreate();
        try {
            loadRequestConf();
        } catch (Exception e) {
            // ここには来ない想定
            Log.e(LOG_TAG, e.getLocalizedMessage());
        }
    }

    public Map<String, String> getmRequestUrls() {
        return mRequestUrls;
    }

    public Map<String, String> getRequestHeaders() {
        return mRequestHeaders;
    }

    private void loadRequestConf() throws IOException {
        AssetManager am = new AssetManager();
        Gson gson = new Gson();
        Type typedMap = new TypeToken<Map<String, Map<String, String>>>() {
        }.getType();
        DEBUG_OUT.accept(LOG_TAG, "typedMap: " + typedMap);
        // gson.fromJson() thorows JsonSyntaxException, JsonIOException
        Map<String, Map<String, String>> map = gson.fromJson(
                new JsonReader(new InputStreamReader(am.open(REQUEST_INFO_FILE))), typedMap);
        mRequestUrls = map.get("urls");
        mRequestHeaders = map.get("headers");
        DEBUG_OUT.accept(LOG_TAG, "RequestUrls: " + mRequestUrls);
        DEBUG_OUT.accept(LOG_TAG, "RequestHeaders: " + mRequestHeaders);
    }
}

private String getJsonText() {
    // JavaプロジェクトならJSONファイルから取得
    // Androidプロジェクトなら全ての入力ウィジットから取得
}
    
// 登録データJSONテキスト取得        
String jsonText = getJsonText(); 
// アプリケーションオブジェクト生成
HealthcareApplication app = new HealthcareApplication();
// アプリケーションオブジェクトからリクエスト情報取得
Map<String, String> urlMap = app.getmRequestUrls();            // ベースURLパスを保持するマップ
Map<String, String> headers = app.getRequestHeaders();         // リクエストヘッダー
String requestUrl = urlMap.get(RequestDevice.WIFI.toString()); // リクエストベースURLパス取得

// データ登録POSTリクエスト用リポジトリ生成
HealthcareRepository<RegisterResult> repository = new ResisterDataRepository();
int urlNum = 0; // 0:登録(register), 1:更新(update)
repository.makeRegisterRequest(urlNum, requestUrl, jsonText, headers,
    app.mEexecutor/*スレッドプール*/, app.mHandler/*ハンドラー*/, (result) -> {
        if (result instanceof Result.Success) {
            // レスポンスOK時の処理
            // Androidの場合はステータスに登録OKを表示
        } else if (result instanceof Result.Warning) {
            // ウォーニングレスポンス時の処理(40x, 501)
            // ウォーニングステータスオブジェクト取得
            ResponseStatus status =
                    ((Result.Warning) result).getResponseStatus();
            // Androidの場合はステータスにエラー内容を表示
        } else {
            // 例外オブジェクト取得
            Exception exception = ((Result.Error) result).getException();
            // 例外発生時の処理 (主にサーバーアプリ側のバグかAndroidアプリ側のバグ[JSONパースエラー等])
            // Androidの場合は例外メッセージをダイアログに表示
        }
    });

// 登録済みデータの主キー項目
String emailAddress = "user1@examples.com";
String pastDay = "2023-03-10";

// アプリケーションオブジェクト生成
HealthcareApplication app = new HealthcareApplication();
// アプリケーションオブジェクトからリクエスト情報取得
Map<String, String> urlMap = app.getmRequestUrls();
Map<String, String> headers = app.getRequestHeaders();
String requestUrl = urlMap.get(RequestDevice.WIFI.toString());

// 登録済みデータ取得GETリクエスト用リポジトリ生成
HealthcareRepository<GetCurrentDataResult> repository = new GetCurrentDataRepository();
// リクエストパラメータ取得(URLエンコード)
String requestParams = AppTopUtil.getRequestParams(emailAddress, pastDay);
repository.makeGetRequest(0, requestUrl, requestParams, headers,
    app.mEexecutor, app.mHandler, (result) -> {
        if (result instanceof Result.Success) {
            // OKレスポンスオブジェクト取得
            GetCurrentDataResult dataResult =
                    ((Result.Success<GetCurrentDataResult>) result).get();
            // 登録済みデータ取得
            RegisterData data = dataResult.getData();
            // Androidの場合は登録済みデータをウィジットに設定
        } else if (result instanceof Result.Warning) {
            // ウォーニングステータスオブジェクト取得
            ResponseStatus status =
                    ((Result.Warning<?>) result).getResponseStatus();
            // Androidの場合はステータスにエラー内容を表示
        } else {
            // 例外オブジェクト取得
            Exception exception = ((Result.Error<?>) result).getException();
            // 例外発生時の処理 (主にサーバーアプリ側のバグかAndroidアプリ側のバグ[JSONパースエラー等])
            // Androidの場合は例外メッセージをダイアログに表示
        }
    });