package server.logic.ws_protocol.JSON.handlers.tempToTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import server.logic.ws_protocol.Base64Ws;
import server.logic.ws_protocol.JSON.ConnectionContext;
import server.logic.ws_protocol.JSON.entyties.Net_Request;
import server.logic.ws_protocol.JSON.entyties.Net_Response;
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_AddUser_Request;
import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_AddUser_Response;
import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
import server.logic.ws_protocol.WireCodes;
import shine.db.SqliteDbController;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.SolanaUsersDAO;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserEntry;
import utils.blockchain.BlockchainNameUtil;

import java.sql.Connection;
import java.sql.SQLException;

public class Net_AddUser_Handler implements JsonMessageHandler {

    private static final Logger log = LoggerFactory.getLogger(Net_AddUser_Handler.class);

    /** TEST ONLY */
    private static final int TEST_BCH_LIMIT = 1_000_000;

    @Override
    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
        Net_AddUser_Request req = (Net_AddUser_Request) baseRequest;

        if (req.getLogin() == null || req.getLogin().isBlank()
                || req.getBlockchainName() == null || req.getBlockchainName().isBlank()
                || req.getSolanaKey() == null || req.getSolanaKey().isBlank()
                || req.getBlockchainKey() == null || req.getBlockchainKey().isBlank()
                || req.getDeviceKey() == null || req.getDeviceKey().isBlank()) {

            return NetExceptionResponseFactory.error(
                    req,
                    WireCodes.Status.BAD_REQUEST,
                    "BAD_FIELDS",
                    "Некорректные поля: login/blockchainName/solanaKey/blockchainKey/deviceKey"
            );
        }

        // blockchainName должен быть вида: <login>-NNN
        if (!BlockchainNameUtil.isBlockchainNameMatchesLogin(req.getBlockchainName(), req.getLogin())) {
            return NetExceptionResponseFactory.error(
                    req,
                    WireCodes.Status.BAD_REQUEST,
                    "BAD_BLOCKCHAIN_NAME",
                    "blockchainName должен быть вида <login>-NNN (пример: anya-001)"
            );
        }

        int limit = (req.getBchLimit() == null || req.getBchLimit() <= 0)
                ? TEST_BCH_LIMIT
                : req.getBchLimit();

        try {
            // базовая валидация форматов ключей: Base64(32 bytes)
            byte[] solanaKey32;
            byte[] blockchainKey32;
            byte[] deviceKey32;

            try {
                solanaKey32 = Base64Ws.decodeLen(req.getSolanaKey(), 32, "solanaKey");
                blockchainKey32 = Base64Ws.decodeLen(req.getBlockchainKey(), 32, "blockchainKey");
                deviceKey32 = Base64Ws.decodeLen(req.getDeviceKey(), 32, "deviceKey");
            } catch (IllegalArgumentException e) {
                return NetExceptionResponseFactory.error(
                        req,
                        WireCodes.Status.BAD_REQUEST,
                        "BAD_KEY_FORMAT",
                        e.getMessage()
                );
            }

            // (переменные не используются дальше, но оставляем для ясности проверки длины)
            if (solanaKey32.length != 32 || blockchainKey32.length != 32 || deviceKey32.length != 32) {
                return NetExceptionResponseFactory.error(
                        req,
                        WireCodes.Status.BAD_REQUEST,
                        "BAD_KEY_FORMAT",
                        "solanaKey/blockchainKey/deviceKey должны быть Base64(32 bytes)"
                );
            }

            SolanaUsersDAO usersDAO = SolanaUsersDAO.getInstance();
            BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();

            SqliteDbController db = SqliteDbController.getInstance();

            try (Connection c = db.getConnection()) {
                c.setAutoCommit(false);

                // 1. Проверяем, что пользователя нет (case-insensitive)
                if (usersDAO.getByLogin(c, req.getLogin()) != null) {
                    return NetExceptionResponseFactory.error(
                            req,
                            409,
                            "USER_ALREADY_EXISTS",
                            "Пользователь с таким login уже существует"
                    );
                }

                // 2. Проверяем, что blockchainName ещё нет (case-sensitive, как в БД)
                if (usersDAO.existsByBlockchainName(c, req.getBlockchainName())) {
                    return NetExceptionResponseFactory.error(
                            req,
                            409,
                            "BLOCKCHAIN_ALREADY_EXISTS",
                            "Пользователь с таким blockchainName уже существует"
                    );
                }

                // 3. На всякий случай оставляем старую проверку blockchain_state,
                //    потому что эта таблица нужна серверу (состояние цепочки/лимиты).
                if (stateDAO.getByBlockchainName(c, req.getBlockchainName()) != null) {
                    return NetExceptionResponseFactory.error(
                            req,
                            409,
                            "BLOCKCHAIN_STATE_ALREADY_EXISTS",
                            "blockchain_state уже существует"
                    );
                }

                // 4. Создаём пользователя (все поля теперь лежат в solana_users)
                SolanaUserEntry user = new SolanaUserEntry();
                user.setLogin(req.getLogin());
                user.setBlockchainName(req.getBlockchainName());
                user.setSolanaKey(req.getSolanaKey());
                user.setBlockchainKey(req.getBlockchainKey());
                user.setDeviceKey(req.getDeviceKey());

                usersDAO.insert(c, user);

                // 5. Создаём INITIAL blockchain_state (для работы сервера)
                BlockchainStateEntry st = new BlockchainStateEntry();
                st.setBlockchainName(req.getBlockchainName());
                st.setLogin(req.getLogin());
                st.setBlockchainKey(req.getBlockchainKey()); // Base64(32)
                st.setLastBlockNumber(-1);
                st.setLastBlockHash(new byte[32]);
                st.setFileSizeBytes(0);
                st.setSizeLimit(limit);
                st.setUpdatedAtMs(System.currentTimeMillis());

                stateDAO.upsert(c, st);

                c.commit();
            }

            Net_AddUser_Response resp = new Net_AddUser_Response();
            resp.setOp(req.getOp());
            resp.setRequestId(req.getRequestId());
            resp.setStatus(WireCodes.Status.OK);

            log.info("✅ AddUser ok: login={}, blockchainName={}, limit={}",
                    req.getLogin(), req.getBlockchainName(), limit);

            return resp;

        } catch (SQLException e) {
            log.error("❌ DB error AddUser", e);
            return NetExceptionResponseFactory.error(
                    req,
                    WireCodes.Status.SERVER_DATA_ERROR,
                    "DB_ERROR",
                    "Ошибка БД"
            );
        } catch (Exception e) {
            log.error("❌ Internal error AddUser", e);
            return NetExceptionResponseFactory.error(
                    req,
                    WireCodes.Status.INTERNAL_ERROR,
                    "INTERNAL_ERROR",
                    NetExceptionResponseFactory.detailedMessage("Внутренняя ошибка сервера при AddUser", e)
            );
        }
    }
}
