package com.ruoyi.web.controller.tool;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import okhttp3.Credentials;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 海康威视智能身份识别终端 DS-K1T6UVSCHT-NX 门禁人员、卡、人脸下发工具。
 */
public final class HikvisionAccessControlApi {

    private static final String USER_INFO_SET_UP_PATH = "/ISAPI/AccessControl/UserInfo/SetUp?format=json";
    private static final String CARD_INFO_SET_UP_PATH = "/ISAPI/AccessControl/CardInfo/SetUp?format=json";
    private static final String FACE_DATA_RECORD_PATH = "/ISAPI/Intelligent/FDLib/FaceDataRecord?format=json";
    private static final String USER_INFO_DELETE_PATH = "/ISAPI/AccessControl/UserInfo/Delete?format=json";
    private static final String CARD_INFO_DELETE_PATH = "/ISAPI/AccessControl/CardInfo/Delete?format=json";
    private static final MediaType JSON_MEDIA_TYPE = MediaType.parse("application/json; charset=utf-8");
    private static final MediaType JPEG_MEDIA_TYPE = MediaType.parse("image/jpeg");
    private static final MediaType PNG_MEDIA_TYPE = MediaType.parse("image/png");
    private static final OkHttpClient CLIENT = new OkHttpClient.Builder()
            .connectTimeout(5, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .writeTimeout(20, TimeUnit.SECONDS)
            .build();

    private HikvisionAccessControlApi() {
    }

    /**
     * 下发员工基础信息，并按员工数据绑定卡号和人脸。
     */
    public static IssueResult issueEmployee(DeviceConfig device, EmployeeCredential employee) throws IOException {
        Objects.requireNonNull(employee, "employee");
        IssueResult result = new IssueResult();
        HikvisionResult userInfo = setupUserInfo(device, employee);
        result.setUserInfo(userInfo);
        ensureSuccess(userInfo, "下发人员信息失败");

        if (isNotBlank(employee.getCardNo())) {
            HikvisionResult card = bindCard(device, employee.getEmployeeNo(), employee.getCardNo());
            result.setCard(card);
            ensureSuccess(card, "绑定员工卡号失败");
        }
        byte[] faceImage = employee.resolveFaceImage();
        if (faceImage != null && faceImage.length > 0) {
            HikvisionResult face = bindFace(device, employee.getEmployeeNo(), faceImage);
            result.setFace(face);
            ensureSuccess(face, "绑定员工人脸失败");
        }
        return result;
    }

    /**
     * 删除门禁人员，并尽量清理绑定卡和人脸凭据。
     */
    public static DeleteResult deleteEmployee(DeviceConfig device, EmployeeCredential employee) throws IOException {
        Objects.requireNonNull(employee, "employee");
        requireText(employee.getEmployeeNo(), "employeeNo");

        DeleteResult result = new DeleteResult();
        if (isNotBlank(employee.getCardNo())) {
            result.setCard(deleteCard(device, employee.getCardNo()));
        }
        result.setFace(deleteFace(device, employee.getEmployeeNo()));

        HikvisionResult userInfo = deleteUserInfo(device, employee.getEmployeeNo());
        result.setUserInfo(userInfo);
        ensureSuccess(userInfo, "delete user info failed");
        return result;
    }

    /**
     * 下发或更新人员基础信息。DS-K1T6UVSCHT-NX 单门场景默认 doorRight=1、doorNo=1、planTemplateNo=1。
     */
    public static HikvisionResult setupUserInfo(DeviceConfig device, EmployeeCredential employee) throws IOException {
        requireDevice(device);
        requireText(employee == null ? null : employee.getEmployeeNo(), "employeeNo");
        requireText(employee.getName(), "name");

        JSONObject valid = new JSONObject(true);
        valid.put("enable", true);
        valid.put("beginTime", defaultIfBlank(employee.getBeginTime(), "2000-01-01T00:00:00"));
        valid.put("endTime", defaultIfBlank(employee.getEndTime(), "2037-12-31T23:59:59"));
        valid.put("timeType", "local");

        JSONObject rightPlan = new JSONObject(true);
        rightPlan.put("doorNo", employee.getDoorNo());
        rightPlan.put("planTemplateNo", defaultIfBlank(employee.getPlanTemplateNo(), "1"));

        JSONObject userInfo = new JSONObject(true);
        userInfo.put("employeeNo", employee.getEmployeeNo());
        userInfo.put("name", employee.getName());
        userInfo.put("userType", defaultIfBlank(employee.getUserType(), "normal"));
        userInfo.put("Valid", valid);
        userInfo.put("doorRight", defaultIfBlank(employee.getDoorRight(), "1"));
        userInfo.put("RightPlan", singletonList(rightPlan));
        userInfo.put("gender", defaultIfBlank(employee.getGender(), "unknown"));
        userInfo.put("localUIRight", false);
        userInfo.put("maxOpenDoorTime", 0);

        JSONObject body = new JSONObject(true);
        body.put("UserInfo", userInfo);
        return executeJson(device, "PUT", USER_INFO_SET_UP_PATH, body);
    }

    /**
     * 绑定员工卡号。
     */
    public static HikvisionResult bindCard(DeviceConfig device, String employeeNo, String cardNo) throws IOException {
        requireDevice(device);
        requireText(employeeNo, "employeeNo");
        requireText(cardNo, "cardNo");

        JSONObject cardInfo = new JSONObject(true);
        cardInfo.put("employeeNo", employeeNo);
        cardInfo.put("cardNo", cardNo);
        cardInfo.put("cardType", "normalCard");
        cardInfo.put("leaderCard", false);
        cardInfo.put("checkCardNo", true);

        JSONObject body = new JSONObject(true);
        body.put("CardInfo", cardInfo);
        return executeJson(device, "PUT", CARD_INFO_SET_UP_PATH, body);
    }

    /**
     * 绑定员工人脸，默认写入设备黑名单人脸库 blackFD/FDID=1，FPID 使用员工编号。
     */
    public static HikvisionResult bindFace(DeviceConfig device, String employeeNo, byte[] faceImage) throws IOException {
        requireDevice(device);
        requireText(employeeNo, "employeeNo");
        if (faceImage == null || faceImage.length == 0) {
            throw new IllegalArgumentException("faceImage 不能为空");
        }

        JSONObject faceData = new JSONObject(true);
        faceData.put("faceLibType", "blackFD");
        faceData.put("FDID", "1");
        faceData.put("FPID", employeeNo);

        RequestBody body = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("FaceDataRecord", "FaceDataRecord",
                        RequestBody.create(JSON_MEDIA_TYPE, JSON.toJSONString(faceData)))
                .addFormDataPart("img", employeeNo + imageSuffix(faceImage),
                        RequestBody.create(resolveImageMediaType(faceImage), faceImage))
                .build();
        return execute(device, new Request.Builder()
                .url(device.resolveUrl(FACE_DATA_RECORD_PATH))
                .put(body)
                .build());
    }

    /**
     * 删除设备端人员基础信息。
     */
    public static HikvisionResult deleteUserInfo(DeviceConfig device, String employeeNo) throws IOException {
        requireDevice(device);
        requireText(employeeNo, "employeeNo");

        JSONObject employeeNoItem = new JSONObject(true);
        employeeNoItem.put("employeeNo", employeeNo);

        JSONObject userInfoDelCond = new JSONObject(true);
        userInfoDelCond.put("EmployeeNoList", singletonList(employeeNoItem));

        JSONObject body = new JSONObject(true);
        body.put("UserInfoDelCond", userInfoDelCond);
        return executeJson(device, "DELETE", USER_INFO_DELETE_PATH, body);
    }

    public static HikvisionResult deleteCard(DeviceConfig device, String cardNo) throws IOException {
        requireDevice(device);
        requireText(cardNo, "cardNo");

        JSONObject cardNoItem = new JSONObject(true);
        cardNoItem.put("cardNo", cardNo);

        JSONObject cardInfoDelCond = new JSONObject(true);
        cardInfoDelCond.put("CardNoList", singletonList(cardNoItem));

        JSONObject body = new JSONObject(true);
        body.put("CardInfoDelCond", cardInfoDelCond);
        return executeJson(device, "DELETE", CARD_INFO_DELETE_PATH, body);
    }

    public static HikvisionResult deleteFace(DeviceConfig device, String employeeNo) throws IOException {
        requireDevice(device);
        requireText(employeeNo, "employeeNo");

        JSONObject faceData = new JSONObject(true);
        faceData.put("faceLibType", "blackFD");
        faceData.put("FDID", "1");
        faceData.put("FPID", employeeNo);

        JSONObject body = new JSONObject(true);
        body.put("FaceDataRecord", faceData);
        return executeJson(device, "DELETE", FACE_DATA_RECORD_PATH, body);
    }

    /**
     * 通过图片 URL 下载人脸并绑定到员工。
     */
    public static HikvisionResult bindFaceByUrl(DeviceConfig device, String employeeNo, String faceImageUrl) throws IOException {
        requireText(faceImageUrl, "faceImageUrl");
        return bindFace(device, employeeNo, downloadImage(faceImageUrl));
    }

    /**
     * 通过 Base64 图片绑定员工人脸，兼容 data:image/jpeg;base64 前缀。
     */
    public static HikvisionResult bindFaceByBase64(DeviceConfig device, String employeeNo, String faceImageBase64) throws IOException {
        requireText(faceImageBase64, "faceImageBase64");
        String value = faceImageBase64;
        int commaIndex = value.indexOf(',');
        if (commaIndex > -1) {
            value = value.substring(commaIndex + 1);
        }
        return bindFace(device, employeeNo, Base64.getDecoder().decode(value));
    }

    private static HikvisionResult executeJson(DeviceConfig device, String method, String path, JSONObject body) throws IOException {
        RequestBody requestBody = RequestBody.create(JSON_MEDIA_TYPE, JSON.toJSONString(body));
        Request.Builder builder = new Request.Builder()
                .url(device.resolveUrl(path))
                .header("Accept", "application/json");
        if ("POST".equals(method)) {
            builder.post(requestBody);
        } else if ("DELETE".equals(method)) {
            builder.delete(requestBody);
        } else {
            builder.put(requestBody);
        }
        return execute(device, builder.build());
    }

    private static HikvisionResult execute(DeviceConfig device, Request request) throws IOException {
        Response response = CLIENT.newCall(request).execute();
        int code = response.code();
        String authenticate = response.header("WWW-Authenticate");
        String body = readBody(response);
        if (code != 401) {
            return HikvisionResult.of(request.url().toString(), code, body);
        }

        if (isBlank(authenticate)) {
            return HikvisionResult.of(request.url().toString(), 401, body);
        }

        Request retryRequest = buildAuthenticatedRequest(device, request, authenticate);
        Response retryResponse = CLIENT.newCall(retryRequest).execute();
        return HikvisionResult.of(retryRequest.url().toString(), retryResponse.code(), readBody(retryResponse));
    }

    private static Request buildAuthenticatedRequest(DeviceConfig device, Request request, String authenticate) {
        String lowerAuthenticate = authenticate.toLowerCase(Locale.ROOT);
        if (lowerAuthenticate.startsWith("digest")) {
            return request.newBuilder()
                    .header("Authorization", buildDigestAuthorization(device, request, authenticate))
                    .build();
        }
        if (lowerAuthenticate.startsWith("basic")) {
            return request.newBuilder()
                    .header("Authorization", Credentials.basic(device.getUsername(), device.getPassword(), StandardCharsets.UTF_8))
                    .build();
        }
        return request;
    }

    private static String buildDigestAuthorization(DeviceConfig device, Request request, String authenticate) {
        Map<String, String> challenge = parseDigestChallenge(authenticate);
        String realm = challenge.get("realm");
        String nonce = challenge.get("nonce");
        String qop = firstQop(challenge.get("qop"));
        String algorithm = defaultIfBlank(challenge.get("algorithm"), "MD5");
        if (!"MD5".equalsIgnoreCase(algorithm)) {
            throw new IllegalArgumentException("不支持的海康 Digest algorithm: " + algorithm);
        }

        String uri = request.url().encodedPath() + (request.url().encodedQuery() == null ? "" : "?" + request.url().encodedQuery());
        String nc = "00000001";
        String cnonce = UUID.randomUUID().toString().replace("-", "");
        String ha1 = md5(device.getUsername() + ":" + realm + ":" + device.getPassword());
        String ha2 = md5(request.method() + ":" + uri);
        String response;
        if (isNotBlank(qop)) {
            response = md5(ha1 + ":" + nonce + ":" + nc + ":" + cnonce + ":" + qop + ":" + ha2);
        } else {
            response = md5(ha1 + ":" + nonce + ":" + ha2);
        }

        List<String> parts = new ArrayList<>();
        parts.add("username=\"" + escapeDigestValue(device.getUsername()) + "\"");
        parts.add("realm=\"" + escapeDigestValue(realm) + "\"");
        parts.add("nonce=\"" + escapeDigestValue(nonce) + "\"");
        parts.add("uri=\"" + escapeDigestValue(uri) + "\"");
        parts.add("response=\"" + response + "\"");
        parts.add("algorithm=MD5");
        if (isNotBlank(challenge.get("opaque"))) {
            parts.add("opaque=\"" + escapeDigestValue(challenge.get("opaque")) + "\"");
        }
        if (isNotBlank(qop)) {
            parts.add("qop=" + qop);
            parts.add("nc=" + nc);
            parts.add("cnonce=\"" + cnonce + "\"");
        }
        return "Digest " + join(parts);
    }

    private static Map<String, String> parseDigestChallenge(String authenticate) {
        String value = authenticate.trim();
        if (value.toLowerCase(Locale.ROOT).startsWith("digest")) {
            value = value.substring(6).trim();
        }
        Map<String, String> result = new LinkedHashMap<>();
        int index = 0;
        while (index < value.length()) {
            while (index < value.length() && (value.charAt(index) == ',' || Character.isWhitespace(value.charAt(index)))) {
                index++;
            }
            int equalsIndex = value.indexOf('=', index);
            if (equalsIndex < 0) {
                break;
            }
            String key = value.substring(index, equalsIndex).trim();
            index = equalsIndex + 1;
            String parsedValue;
            if (index < value.length() && value.charAt(index) == '"') {
                StringBuilder builder = new StringBuilder();
                index++;
                while (index < value.length()) {
                    char ch = value.charAt(index++);
                    if (ch == '\\' && index < value.length()) {
                        builder.append(value.charAt(index++));
                    } else if (ch == '"') {
                        break;
                    } else {
                        builder.append(ch);
                    }
                }
                parsedValue = builder.toString();
            } else {
                int commaIndex = value.indexOf(',', index);
                if (commaIndex < 0) {
                    parsedValue = value.substring(index).trim();
                    index = value.length();
                } else {
                    parsedValue = value.substring(index, commaIndex).trim();
                    index = commaIndex + 1;
                }
            }
            if (isNotBlank(key)) {
                result.put(key, parsedValue);
            }
        }
        return result;
    }

    private static byte[] downloadImage(String url) throws IOException {
        Request request = new Request.Builder().url(url).get().build();
        Response response = CLIENT.newCall(request).execute();
        try {
            if (!response.isSuccessful()) {
                throw new IOException("下载人脸图片失败，HTTP " + response.code());
            }
            ResponseBody body = response.body();
            if (body == null) {
                throw new IOException("下载人脸图片失败，响应为空");
            }
            return body.bytes();
        } finally {
            response.close();
        }
    }

    private static void ensureSuccess(HikvisionResult result, String message) throws IOException {
        if (result == null || !result.isSuccess()) {
            throw new IOException(message + "，设备响应：" + (result == null ? "" : result.getBody()));
        }
    }

    private static void requireDevice(DeviceConfig device) {
        Objects.requireNonNull(device, "device");
        requireText(device.getUsername(), "username");
        requireText(device.getPassword(), "password");
        if (isBlank(device.getBaseUrl()) && isBlank(device.getHost())) {
            throw new IllegalArgumentException("baseUrl 或 host 不能为空");
        }
    }

    private static void requireText(String value, String fieldName) {
        if (isBlank(value)) {
            throw new IllegalArgumentException(fieldName + " 不能为空");
        }
    }

    private static String readBody(Response response) throws IOException {
        try {
            ResponseBody body = response.body();
            return body == null ? "" : body.string();
        } finally {
            response.close();
        }
    }

    private static String firstQop(String qop) {
        if (isBlank(qop)) {
            return "";
        }
        String[] values = qop.split(",");
        for (String value : values) {
            if ("auth".equals(value.trim())) {
                return "auth";
            }
        }
        return values[0].trim();
    }

    private static String md5(String value) {
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            byte[] bytes = digest.digest(value.getBytes(StandardCharsets.ISO_8859_1));
            StringBuilder builder = new StringBuilder(bytes.length * 2);
            for (byte b : bytes) {
                String hex = Integer.toHexString(b & 0xff);
                if (hex.length() == 1) {
                    builder.append('0');
                }
                builder.append(hex);
            }
            return builder.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException("当前 JDK 不支持 MD5", e);
        }
    }

    private static String escapeDigestValue(String value) {
        return value == null ? "" : value.replace("\\", "\\\\").replace("\"", "\\\"");
    }

    private static MediaType resolveImageMediaType(byte[] bytes) {
        return isPng(bytes) ? PNG_MEDIA_TYPE : JPEG_MEDIA_TYPE;
    }

    private static String imageSuffix(byte[] bytes) {
        return isPng(bytes) ? ".png" : ".jpg";
    }

    private static boolean isPng(byte[] bytes) {
        return bytes.length > 4
                && (bytes[0] & 0xff) == 0x89
                && bytes[1] == 0x50
                && bytes[2] == 0x4e
                && bytes[3] == 0x47;
    }

    private static String join(List<String> values) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < values.size(); i++) {
            if (i > 0) {
                builder.append(", ");
            }
            builder.append(values.get(i));
        }
        return builder.toString();
    }

    private static String defaultIfBlank(String value, String defaultValue) {
        return isBlank(value) ? defaultValue : value;
    }

    private static boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }

    private static boolean isNotBlank(String value) {
        return !isBlank(value);
    }

    private static List<JSONObject> singletonList(JSONObject value) {
        List<JSONObject> list = new ArrayList<>(1);
        list.add(value);
        return list;
    }

    public static final class DeviceConfig {
        private String baseUrl;
        private String host;
        private int port = 80;
        private boolean https;
        private String username;
        private String password;

        public static DeviceConfig http(String host, String username, String password) {
            DeviceConfig config = new DeviceConfig();
            config.setHost(host);
            config.setUsername(username);
            config.setPassword(password);
            return config;
        }

        public String resolveUrl(String path) {
            String base = isNotBlank(baseUrl) ? baseUrl.trim() : buildBaseUrl();
            while (base.endsWith("/")) {
                base = base.substring(0, base.length() - 1);
            }
            return base + path;
        }

        private String buildBaseUrl() {
            String value = host.trim();
            if (value.startsWith("http://") || value.startsWith("https://")) {
                return value;
            }
            String scheme = https ? "https://" : "http://";
            boolean appendPort = port > 0 && !hasPort(value);
            return scheme + value + (appendPort ? ":" + port : "");
        }

        private boolean hasPort(String value) {
            int colonIndex = value.lastIndexOf(':');
            return colonIndex > -1 && colonIndex < value.length() - 1 && value.indexOf(']') < colonIndex;
        }

        public String getBaseUrl() {
            return baseUrl;
        }

        public void setBaseUrl(String baseUrl) {
            this.baseUrl = baseUrl;
        }

        public String getHost() {
            return host;
        }

        public void setHost(String host) {
            this.host = host;
        }

        public int getPort() {
            return port;
        }

        public void setPort(int port) {
            this.port = port;
        }

        public boolean isHttps() {
            return https;
        }

        public void setHttps(boolean https) {
            this.https = https;
        }

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
    }

    public static final class EmployeeCredential {
        private String employeeNo;
        private String name;
        private String cardNo;
        private byte[] faceImage;
        private String faceImageUrl;
        private String faceImageBase64;
        private String beginTime;
        private String endTime;
        private String userType = "normal";
        private String doorRight = "1";
        private int doorNo = 1;
        private String planTemplateNo = "1";
        private String gender = "unknown";

        public static EmployeeCredential of(String employeeNo, String name, String cardNo) {
            EmployeeCredential credential = new EmployeeCredential();
            credential.setEmployeeNo(employeeNo);
            credential.setName(name);
            credential.setCardNo(cardNo);
            return credential;
        }

        private byte[] resolveFaceImage() throws IOException {
            if (faceImage != null && faceImage.length > 0) {
                return faceImage;
            }
            if (isNotBlank(faceImageBase64)) {
                String value = faceImageBase64;
                int commaIndex = value.indexOf(',');
                if (commaIndex > -1) {
                    value = value.substring(commaIndex + 1);
                }
                return Base64.getDecoder().decode(value);
            }
            if (isNotBlank(faceImageUrl)) {
                return downloadImage(faceImageUrl);
            }
            return null;
        }

        public String getEmployeeNo() {
            return employeeNo;
        }

        public void setEmployeeNo(String employeeNo) {
            this.employeeNo = employeeNo;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getCardNo() {
            return cardNo;
        }

        public void setCardNo(String cardNo) {
            this.cardNo = cardNo;
        }

        public byte[] getFaceImage() {
            return faceImage;
        }

        public void setFaceImage(byte[] faceImage) {
            this.faceImage = faceImage;
        }

        public String getFaceImageUrl() {
            return faceImageUrl;
        }

        public void setFaceImageUrl(String faceImageUrl) {
            this.faceImageUrl = faceImageUrl;
        }

        public String getFaceImageBase64() {
            return faceImageBase64;
        }

        public void setFaceImageBase64(String faceImageBase64) {
            this.faceImageBase64 = faceImageBase64;
        }

        public String getBeginTime() {
            return beginTime;
        }

        public void setBeginTime(String beginTime) {
            this.beginTime = beginTime;
        }

        public String getEndTime() {
            return endTime;
        }

        public void setEndTime(String endTime) {
            this.endTime = endTime;
        }

        public String getUserType() {
            return userType;
        }

        public void setUserType(String userType) {
            this.userType = userType;
        }

        public String getDoorRight() {
            return doorRight;
        }

        public void setDoorRight(String doorRight) {
            this.doorRight = doorRight;
        }

        public int getDoorNo() {
            return doorNo;
        }

        public void setDoorNo(int doorNo) {
            this.doorNo = doorNo;
        }

        public String getPlanTemplateNo() {
            return planTemplateNo;
        }

        public void setPlanTemplateNo(String planTemplateNo) {
            this.planTemplateNo = planTemplateNo;
        }

        public String getGender() {
            return gender;
        }

        public void setGender(String gender) {
            this.gender = gender;
        }
    }

    public static final class DeleteResult {
        private HikvisionResult userInfo;
        private HikvisionResult card;
        private HikvisionResult face;

        public HikvisionResult getUserInfo() {
            return userInfo;
        }

        public void setUserInfo(HikvisionResult userInfo) {
            this.userInfo = userInfo;
        }

        public HikvisionResult getCard() {
            return card;
        }

        public void setCard(HikvisionResult card) {
            this.card = card;
        }

        public HikvisionResult getFace() {
            return face;
        }

        public void setFace(HikvisionResult face) {
            this.face = face;
        }
    }

    public static final class IssueResult {
        private HikvisionResult userInfo;
        private HikvisionResult card;
        private HikvisionResult face;

        public HikvisionResult getUserInfo() {
            return userInfo;
        }

        public void setUserInfo(HikvisionResult userInfo) {
            this.userInfo = userInfo;
        }

        public HikvisionResult getCard() {
            return card;
        }

        public void setCard(HikvisionResult card) {
            this.card = card;
        }

        public HikvisionResult getFace() {
            return face;
        }

        public void setFace(HikvisionResult face) {
            this.face = face;
        }
    }

    public static final class HikvisionResult {
        private String url;
        private int httpCode;
        private String body;

        private static HikvisionResult of(String url, int httpCode, String body) {
            HikvisionResult result = new HikvisionResult();
            result.setUrl(url);
            result.setHttpCode(httpCode);
            result.setBody(body);
            return result;
        }

        public boolean isSuccess() {
            if (httpCode < 200 || httpCode >= 300) {
                return false;
            }
            if (isBlank(body)) {
                return true;
            }
            try {
                JSONObject root = JSON.parseObject(body);
                Object statusCode = root.get("statusCode");
                if (statusCode == null && root.getJSONObject("ResponseStatus") != null) {
                    statusCode = root.getJSONObject("ResponseStatus").get("statusCode");
                }
                if (statusCode == null) {
                    return true;
                }
                if (statusCode instanceof Number) {
                    return ((Number) statusCode).intValue() == 1;
                }
                String value = String.valueOf(statusCode);
                return "1".equals(value) || "OK".equalsIgnoreCase(value) || "ok".equalsIgnoreCase(value);
            } catch (Exception e) {
                return true;
            }
        }

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        public int getHttpCode() {
            return httpCode;
        }

        public void setHttpCode(int httpCode) {
            this.httpCode = httpCode;
        }

        public String getBody() {
            return body;
        }

        public void setBody(String body) {
            this.body = body;
        }
    }
}