import { base58ToBytes, base64ToBytes, bytesToBase58, importPkcs8Ed25519, sha256Bytes, signBytes } from './crypto-utils.js';
import { extractSeed32FromPkcs8B64 } from './client-key-utils.js';
import {
  SHINE_LOGIN_GUARD_PROGRAM_ID,
  SHINE_PAYMENTS_PROGRAM_ID,
  SHINE_USERS_ECONOMY_CONFIG_SEED,
  SHINE_USERS_PROGRAM_ID,
} from '../solana-programs.js';
import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js';

const MAGIC = 'SHiNE';
const FORMAT_MAJOR = 1;
const FORMAT_MINOR_LEGACY = 0;
const FORMAT_MINOR_CURRENT = 2;
const SHINE_PAYMENTS_INFLOW_VAULT_SEED = 'shine_payments_inflow_vault';
const SHINE_USERS_USER_PDA_SEED_PREFIX = 'user_login=';
const SHINE_USERS_PROMO_SELLER_PDA_SEED_PREFIX = 'promo_seller=';
const LIMIT_STEP = 10_000n;
const ED25519_PROGRAM_ID = 'Ed25519SigVerify111111111111111111111111111';
const SYSVAR_INSTRUCTIONS_ID = 'Sysvar1nstructions1111111111111111111111111';
const PROMO_SIGN_PREFIX = 'shine_promo_v1:';

const BLOCK_TYPE_ROOT_KEY = 1;
const BLOCK_TYPE_CLIENT_KEY = 2;
const BLOCK_TYPE_BLOCKCHAIN_REGISTRY = 3;
const BLOCK_TYPE_SERVER_PROFILE = 30;
const BLOCK_TYPE_ACCESS_SERVERS = 40;

const AUTH_MODE_BLOCKCHAIN = 0;
const AUTH_MODE_ROOT = 1;
const IX_CREATE_USER_PDA = 3;
const IX_UPDATE_USER_PDA = 4;
const IX_CLOSE_LEGACY_USER_PDA = 6;
const DAY_MS = 86_400_000n;
const FORK_COOLDOWN_MS = 3n * DAY_MS;
const MAX_EFFECTIVE_ACCESS_SERVERS = 1;

let solanaLibPromise = null;
function loadSolanaLib() {
  if (!solanaLibPromise) solanaLibPromise = loadSolanaWeb3();
  return solanaLibPromise;
}

function normalizeLogin(login) {
  return String(login || '').trim().toLowerCase();
}

function normalizeAccessServers(values) {
  const seen = new Set();
  const result = [];
  for (const value of Array.isArray(values) ? values : []) {
    const login = normalizeLogin(value);
    if (!login || seen.has(login)) continue;
    if (result.length >= MAX_EFFECTIVE_ACCESS_SERVERS) {
      throw new Error('PDA 1.2 поддерживает максимум один сервер доступа');
    }
    seen.add(login);
    result.push(login);
  }
  return result;
}

function toUint8Array(value, expectedLength = null) {
  const bytes = value instanceof Uint8Array ? value : new Uint8Array(value || []);
  if (expectedLength != null && bytes.length !== expectedLength) {
    throw new Error(`Ожидалось ${expectedLength} байт, получено ${bytes.length}`);
  }
  return bytes;
}

function pushU16LE(buf, value) {
  const n = Number(value) & 0xffff;
  buf.push(n & 0xff, (n >>> 8) & 0xff);
}

function pushU32LE(buf, value) {
  const n = Number(value) >>> 0;
  buf.push(n & 0xff, (n >>> 8) & 0xff, (n >>> 16) & 0xff, (n >>> 24) & 0xff);
}

function pushU64LE(buf, value) {
  const b = BigInt(value);
  const lo = Number(b & 0xffffffffn) >>> 0;
  const hi = Number((b >> 32n) & 0xffffffffn) >>> 0;
  pushU32LE(buf, lo);
  pushU32LE(buf, hi);
}

function pushStrU8(buf, value) {
  const bytes = new TextEncoder().encode(String(value || ''));
  if (bytes.length > 255) throw new Error('Слишком длинная строка для формата U8');
  buf.push(bytes.length);
  for (const x of bytes) buf.push(x);
}

function pushBytes(buf, bytes) {
  for (const x of toUint8Array(bytes)) buf.push(x);
}

function makeReader(bytes) {
  let offset = 0;
  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
  const ensure = (len) => {
    if (offset + len > bytes.length) throw new Error('Повреждённый формат PDA');
  };
  return {
    readU8() { ensure(1); return view.getUint8(offset++); },
    readU16() { ensure(2); const v = view.getUint16(offset, true); offset += 2; return v; },
    readU32() { ensure(4); const v = view.getUint32(offset, true); offset += 4; return v; },
    readU64() { ensure(8); const v = view.getBigUint64(offset, true); offset += 8; return v; },
    readBytes(len) { ensure(len); const out = bytes.slice(offset, offset + len); offset += len; return out; },
    readStrU8() { const len = this.readU8(); return new TextDecoder().decode(this.readBytes(len)); },
    skip(len) { ensure(len); offset += len; },
    get offset() { return offset; },
    get remaining() { return bytes.length - offset; },
  };
}

function parseUsersEconomyConfig(dataBytes) {
  const view = new DataView(dataBytes.buffer, dataBytes.byteOffset, dataBytes.byteLength);
  if (dataBytes.byteLength < 25) throw new Error('Некорректный economy config');
  return {
    version: view.getUint8(0),
    registrationFeeLamports: view.getBigUint64(1, true),
    lamportsPerLimitStep: view.getBigUint64(9, true),
    startBonusLimit: view.getBigUint64(17, true),
  };
}

function buildEd25519IxData(sig64, pubkey32, messageBytes) {
  const sig = toUint8Array(sig64, 64);
  const pub = toUint8Array(pubkey32, 32);
  const msg = toUint8Array(messageBytes);
  const sigOff = 16;
  const pkOff = sigOff + 64;
  const msgOff = pkOff + 32;
  const data = new Uint8Array(msgOff + msg.length);
  const view = new DataView(data.buffer);
  data[0] = 1;
  data[1] = 0;
  view.setUint16(2, sigOff, true);
  view.setUint16(4, 0xffff, true);
  view.setUint16(6, pkOff, true);
  view.setUint16(8, 0xffff, true);
  view.setUint16(10, msgOff, true);
  view.setUint16(12, msg.length, true);
  view.setUint16(14, 0xffff, true);
  data.set(sig, sigOff);
  data.set(pub, pkOff);
  data.set(msg, msgOff);
  return data;
}

function normalizeServerAddresses(values, fallback = null) {
  const src = Array.isArray(values) && values.length ? values : (fallback ? [fallback] : []);
  if (src.length > 1) throw new Error('PDA 1.2 поддерживает только один адрес сервера');
  return src.map((item) => {
    const address = String(item?.address ?? item?.serverAddress ?? '').trim();
    const bytes = new TextEncoder().encode(address);
    if (!address || bytes.length > 255) throw new Error('Адрес сервера должен занимать 1..255 байт UTF-8');
    return {
      addressFormatType: Number(item?.addressFormatType ?? 0) & 0xff,
      addressFormatVersion: Number(item?.addressFormatVersion ?? 0) & 0xff,
      address,
    };
  });
}

function activeBlockchainCompatibility(login, forks) {
  const active = forks.at(-1) || null;
  if (!active) return null;
  return {
    blockchainType: 1,
    blockchainName: `${normalizeLogin(login)}-${String(forks.length).padStart(3, '0')}`,
    blockchainPublicKey: active.blockchainKey,
    paidLimitBytes: BigInt(active.paidLimitBytes),
    // Эти поля больше не хранятся в PDA 1.2; оставлены как compatibility view для старого UI.
    usedBytes: 0n,
    lastBlockNumber: 0,
    lastBlockHash: new Uint8Array(32),
    lastBlockSignature: new Uint8Array(64),
    arweaveTxId: '',
  };
}

function parseV12Pda(bytes, header) {
  const reader = makeReader(bytes.slice(header.blocksOffset, header.recordLen - 64));
  let rootKey = null;
  let clientKey = null;
  let forks = null;
  let serverAddresses = [];
  let accessServers = [];

  for (let i = 0; i < header.blocksCount; i += 1) {
    const blockType = reader.readU8();
    const blockVersion = reader.readU8();
    if (blockType === BLOCK_TYPE_ROOT_KEY) {
      if (blockVersion !== 0 || rootKey) throw new Error('Некорректный RootKeyBlock');
      rootKey = reader.readBytes(32);
      continue;
    }
    if (blockType === BLOCK_TYPE_CLIENT_KEY) {
      if (blockVersion !== 0 || clientKey) throw new Error('Некорректный ClientKeyBlock');
      clientKey = reader.readBytes(32);
      continue;
    }
    const payloadLen = reader.readU16();
    const payload = makeReader(reader.readBytes(payloadLen));
    if (blockVersion !== 0) continue;
    if (blockType === BLOCK_TYPE_BLOCKCHAIN_REGISTRY) {
      const count = payload.readU16();
      if (count < 1) throw new Error('BlockchainRegistry не содержит fork');
      forks = [];
      for (let j = 0; j < count; j += 1) {
        forks.push({
          blockchainKey: payload.readBytes(32),
          createdAtMs: payload.readU64(),
          paidLimitBytes: BigInt(payload.readU32()),
        });
      }
      if (payload.remaining !== 0) throw new Error('Повреждённый BlockchainRegistry');
    } else if (blockType === BLOCK_TYPE_SERVER_PROFILE) {
      const count = payload.readU8();
      if (count !== 1) throw new Error('PDA 1.2 допускает ровно один адрес в ServerProfileBlock');
      serverAddresses = [];
      for (let j = 0; j < count; j += 1) {
        serverAddresses.push({
          addressFormatType: payload.readU8(),
          addressFormatVersion: payload.readU8(),
          address: payload.readStrU8(),
        });
      }
      if (payload.remaining !== 0) throw new Error('Повреждённый ServerProfileBlock');
    } else if (blockType === BLOCK_TYPE_ACCESS_SERVERS) {
      const count = payload.readU8();
      if (count > 1) throw new Error('PDA 1.2 допускает максимум один access server');
      accessServers = [];
      for (let j = 0; j < count; j += 1) accessServers.push(payload.readStrU8());
      if (payload.remaining !== 0) throw new Error('Повреждённый AccessServersBlock');
    }
  }
  if (!rootKey || !clientKey || !forks) throw new Error('PDA 1.2 не содержит обязательные блоки');
  const firstAddress = serverAddresses[0] || null;
  const blockchain = activeBlockchainCompatibility(header.login, forks);
  return {
    ...header,
    isLegacy: false,
    recoveryKey: null,
    rootKey,
    clientKey,
    forks,
    blockchain,
    isServer: serverAddresses.length > 0,
    serverAddresses,
    serverProfile: firstAddress ? { ...firstAddress, serverAddress: firstAddress.address, addresses: serverAddresses } : null,
    serverData: firstAddress ? { ...firstAddress, serverAddress: firstAddress.address, addresses: serverAddresses } : null,
    addressFormatType: firstAddress?.addressFormatType ?? 0,
    addressFormatVersion: firstAddress?.addressFormatVersion ?? 0,
    serverAddress: firstAddress?.address ?? '',
    syncServers: [],
    accessServers: normalizeAccessServers(accessServers),
    sessionsMode: 1,
    sessions: [],
    trustedCount: 0,
    archiveHeadTxId: '',
    archiveHeadHash: new Uint8Array(32),
  };
}

export function parseShineUserPda(dataBytes) {
  const bytes = toUint8Array(dataBytes);
  const reader = makeReader(bytes);
  const magic = new TextDecoder().decode(reader.readBytes(5));
  if (magic !== MAGIC) throw new Error('Некорректный формат PDA');
  const formatMajor = reader.readU8();
  const formatMinor = reader.readU8();
  const recordLen = reader.readU16();
  if (formatMajor !== FORMAT_MAJOR || formatMinor !== FORMAT_MINOR_CURRENT) throw new Error(`Неподдерживаемый формат PDA ${formatMajor}.${formatMinor}`);
  if (recordLen < 9 + 64 || recordLen > bytes.length) throw new Error('Некорректный record_len');
  const createdAtMs = reader.readU64();
  const updatedAtMs = reader.readU64();
  const recordNumber = reader.readU32();
  const prevRecordHash = reader.readBytes(32);
  const login = reader.readStrU8();
  const blocksCount = reader.readU8();
  const blocksOffset = reader.offset;
  const signature = bytes.slice(recordLen - 64, recordLen);
  const unsignedBytes = bytes.slice(0, recordLen - 64);
  const header = { formatMajor, formatMinor, recordLen, createdAtMs, updatedAtMs, recordNumber, prevRecordHash, login, blocksCount, blocksOffset, signature, unsignedBytes };
  return parseV12Pda(bytes, header);
}

function writeVariableBlock(out, blockType, writer) {
  out.push(blockType, 0);
  const lenPos = out.length;
  pushU16LE(out, 0);
  const start = out.length;
  writer(out);
  const len = out.length - start;
  if (len > 0xffff) throw new Error('Слишком большой payload блока PDA');
  out[lenPos] = len & 0xff;
  out[lenPos + 1] = (len >>> 8) & 0xff;
}

export function serializeUnsignedRecordFromState(stateLike) {
  const state = stateLike || {};
  const login = String(state.login || '');
  const loginBytes = new TextEncoder().encode(login);
  if (loginBytes.length > 255) throw new Error('Слишком длинный логин');
  const forks = Array.isArray(state.forks) ? state.forks : [];
  if (!forks.length || forks.length > 0xffff) throw new Error('Некорректный список fork');
  const serverAddresses = normalizeServerAddresses(state.serverAddresses || []);
  const accessServers = normalizeAccessServers(state.accessServers || []);
  const out = [];
  pushBytes(out, new TextEncoder().encode(MAGIC));
  out.push(FORMAT_MAJOR, FORMAT_MINOR_CURRENT);
  pushU16LE(out, 0);
  pushU64LE(out, BigInt(state.createdAtMs || 0));
  pushU64LE(out, BigInt(state.updatedAtMs || 0));
  pushU32LE(out, Number(state.recordNumber || 0));
  pushBytes(out, toUint8Array(state.prevRecordHash, 32));
  pushStrU8(out, login);
  let blocksCount = 3;
  if (serverAddresses.length) blocksCount += 1;
  if (accessServers.length) blocksCount += 1;
  out.push(blocksCount);

  out.push(BLOCK_TYPE_ROOT_KEY, 0);
  pushBytes(out, toUint8Array(state.rootKey, 32));
  out.push(BLOCK_TYPE_CLIENT_KEY, 0);
  pushBytes(out, toUint8Array(state.clientKey, 32));

  writeVariableBlock(out, BLOCK_TYPE_BLOCKCHAIN_REGISTRY, (payload) => {
    pushU16LE(payload, forks.length);
    for (const fork of forks) {
      pushBytes(payload, toUint8Array(fork.blockchainKey, 32));
      pushU64LE(payload, BigInt(fork.createdAtMs || 0));
      const limit = BigInt(fork.paidLimitBytes || 0);
      if (limit < 0n || limit > 0xffffffffn) throw new Error('paid_limit_bytes не помещается в u32');
      pushU32LE(payload, Number(limit));
    }
  });

  if (serverAddresses.length) {
    writeVariableBlock(out, BLOCK_TYPE_SERVER_PROFILE, (payload) => {
      payload.push(serverAddresses.length);
      for (const item of serverAddresses) {
        payload.push(item.addressFormatType, item.addressFormatVersion);
        pushStrU8(payload, item.address);
      }
    });
  }
  if (accessServers.length) {
    writeVariableBlock(out, BLOCK_TYPE_ACCESS_SERVERS, (payload) => {
      payload.push(accessServers.length);
      for (const value of accessServers) pushStrU8(payload, value);
    });
  }
  const recordLen = out.length + 64;
  if (recordLen > 0xffff) throw new Error('PDA record слишком большой');
  out[7] = recordLen & 0xff;
  out[8] = (recordLen >>> 8) & 0xff;
  return new Uint8Array(out);
}

function serializeCreateUserPdaArgs(args) {
  const out = [IX_CREATE_USER_PDA];
  pushStrU8(out, args.login);
  pushBytes(out, toUint8Array(args.rootKey32, 32));
  pushU64LE(out, args.createdAtMs);
  pushU64LE(out, BigInt(args.additionalLimitBytes || 0));
  pushBytes(out, toUint8Array(args.clientKey32, 32));
  pushBytes(out, toUint8Array(args.blockchainKey32, 32));
  const addresses = normalizeServerAddresses(args.serverAddresses || []);
  out.push(addresses.length);
  for (const item of addresses) {
    out.push(item.addressFormatType, item.addressFormatVersion);
    pushStrU8(out, item.address);
  }
  const access = normalizeAccessServers(args.accessServers || []);
  out.push(access.length);
  for (const value of access) pushStrU8(out, value);
  pushBytes(out, toUint8Array(args.recordSignature64, 64));
  const promo = normalizeLogin(args.promoSellerLogin || '');
  if (promo) pushStrU8(out, promo);
  return new Uint8Array(out);
}

function serializeUpdateUserPdaArgs(args) {
  const out = [IX_UPDATE_USER_PDA];
  pushStrU8(out, args.login);
  pushBytes(out, toUint8Array(args.rootKey32, 32));
  pushU64LE(out, args.updatedAtMs);
  pushU64LE(out, BigInt(args.additionalLimitBytes || 0));
  pushBytes(out, toUint8Array(args.clientKey32, 32));
  out.push(Number(args.authMode) & 0xff);
  if (args.newBlockchainKey32) {
    out.push(1);
    pushBytes(out, toUint8Array(args.newBlockchainKey32, 32));
  } else out.push(0);
  const addresses = normalizeServerAddresses(args.serverAddresses || []);
  out.push(addresses.length);
  for (const item of addresses) {
    out.push(item.addressFormatType, item.addressFormatVersion);
    pushStrU8(out, item.address);
  }
  const access = normalizeAccessServers(args.accessServers || []);
  out.push(access.length);
  for (const value of access) pushStrU8(out, value);
  pushBytes(out, toUint8Array(args.recordSignature64, 64));
  return new Uint8Array(out);
}

function serializeCloseLegacyArgs(login) {
  const out = [IX_CLOSE_LEGACY_USER_PDA];
  pushStrU8(out, login);
  return new Uint8Array(out);
}

export function buildLastBlockStateBytes(login, blockchainName, lastBlockNumber = 0, lastBlockHash32 = new Uint8Array(32), usedBytes = 0n) {
  // Legacy helper kept for old UI diagnostics. PDA 1.2 no longer stores blockchain tip state.
  const out = [];
  pushBytes(out, new TextEncoder().encode('SHiNE_LAST_BLOCK'));
  pushStrU8(out, login);
  pushStrU8(out, blockchainName);
  pushU32LE(out, lastBlockNumber);
  pushBytes(out, toUint8Array(lastBlockHash32, 32));
  pushU64LE(out, usedBytes);
  return new Uint8Array(out);
}

export function buildPromoMessageBytes(login) {
  return new TextEncoder().encode(`${PROMO_SIGN_PREFIX}${normalizeLogin(login)}`);
}

export function buildPromoCodeString(sellerLogin, signatureBytes) {
  const cleanSellerLogin = normalizeLogin(sellerLogin);
  const sig = toUint8Array(signatureBytes, 64);
  return `1${cleanSellerLogin}-${bytesToBase58(sig)}`;
}

export async function findPromoSellerPda({ sellerLogin }) {
  const cleanSellerLogin = normalizeLogin(sellerLogin);
  if (!cleanSellerLogin) throw new Error('Не указан логин продавца');
  const solana = await loadSolanaLib();
  const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID);
  const [promoSellerPda] = solana.PublicKey.findProgramAddressSync(
    [new TextEncoder().encode(SHINE_USERS_PROMO_SELLER_PDA_SEED_PREFIX), new TextEncoder().encode(cleanSellerLogin)],
    usersProgram,
  );
  return { sellerLogin: cleanSellerLogin, promoSellerPda: promoSellerPda.toBase58() };
}

export async function getShineUsersEconomyConfig({ solanaEndpoint }) {
  const solana = await loadSolanaLib();
  const connection = new solana.Connection(String(solanaEndpoint || '').trim(), 'confirmed');
  const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID);
  const [pda] = solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_ECONOMY_CONFIG_SEED)], usersProgram);
  const info = await connection.getAccountInfo(pda, 'confirmed');
  if (!info?.data) throw new Error('Economy config не инициализирован');
  return parseUsersEconomyConfig(new Uint8Array(info.data));
}

export async function readShineUserPda({ login, solanaEndpoint }) {
  const cleanLogin = normalizeLogin(login);
  const solana = await loadSolanaLib();
  const endpoint = String(solanaEndpoint || '').trim();
  const connection = new solana.Connection(endpoint, 'confirmed');
  const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID);
  const [pda] = solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_USER_PDA_SEED_PREFIX), new TextEncoder().encode(cleanLogin)], usersProgram);
  const info = await connection.getAccountInfo(pda, 'confirmed');
  if (!info?.data) throw new Error(`PDA пользователя @${cleanLogin} не найдена`);
  return { ...parseShineUserPda(new Uint8Array(info.data)), pdaAddress: pda.toBase58(), endpoint };
}

export async function readShineUserPdaByAddress({ pdaAddress, solanaEndpoint }) {
  const solana = await loadSolanaLib();
  const endpoint = String(solanaEndpoint || '').trim();
  const connection = new solana.Connection(endpoint, 'confirmed');
  const pubkey = new solana.PublicKey(String(pdaAddress || '').trim());
  const info = await connection.getAccountInfo(pubkey, 'confirmed');
  if (!info?.data) throw new Error('PDA не найдена');
  return { ...parseShineUserPda(new Uint8Array(info.data)), pdaAddress: pubkey.toBase58(), endpoint };
}

export async function readShineUserPdaByRef({ value, solanaEndpoint }) {
  const raw = String(value || '').trim();
  if (!raw) throw new Error('Не указан логин или PDA');
  try { return await readShineUserPdaByAddress({ pdaAddress: raw, solanaEndpoint }); } catch { return readShineUserPda({ login: raw, solanaEndpoint }); }
}

export async function getShineBlockchainUsage({ login, solanaEndpoint }) {
  const state = await readShineUserPda({ login, solanaEndpoint });
  const bch = state.blockchain;
  if (!bch) throw new Error('BlockchainRegistry отсутствует');
  const usedBytes = state.isLegacy ? BigInt(bch.usedBytes) : 0n;
  return {
    login: state.login,
    blockchainName: bch.blockchainName,
    blockchainPublicKey: bch.blockchainPublicKey,
    paidLimitBytes: BigInt(bch.paidLimitBytes),
    usedBytes,
    leftBytes: BigInt(bch.paidLimitBytes) > usedBytes ? BigInt(bch.paidLimitBytes) - usedBytes : 0n,
    lastBlockNumber: state.isLegacy ? bch.lastBlockNumber : 0,
    lastBlockHash: state.isLegacy ? bch.lastBlockHash : new Uint8Array(32),
    usageStoredInPda: state.isLegacy,
    pdaState: state,
  };
}

async function attachSolanaLogs(error, connection) {
  try {
    if (typeof error?.getLogs === 'function') error.solanaLogs = await error.getLogs(connection);
  } catch {}
  return error;
}

async function buildCommonContext({ login, clientPrivatePkcs8B64, payerPrivatePkcs8B64 = '', solanaEndpoint }) {
  const cleanLogin = normalizeLogin(login);
  const solana = await loadSolanaLib();
  const endpoint = String(solanaEndpoint || '').trim();
  const connection = new solana.Connection(endpoint, 'confirmed');
  const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID);
  const paymentsProgram = new solana.PublicKey(SHINE_PAYMENTS_PROGRAM_ID);
  const loginGuardProgram = new solana.PublicKey(SHINE_LOGIN_GUARD_PROGRAM_ID);
  const ed25519Program = new solana.PublicKey(ED25519_PROGRAM_ID);
  const sysvarInstructions = new solana.PublicKey(SYSVAR_INSTRUCTIONS_ID);
  const enc = new TextEncoder();
  const [userPda] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_USERS_USER_PDA_SEED_PREFIX), enc.encode(cleanLogin)], usersProgram);
  const [economyConfigPda] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_USERS_ECONOMY_CONFIG_SEED)], usersProgram);
  const [inflowVault] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_PAYMENTS_INFLOW_VAULT_SEED)], paymentsProgram);
  const payerPkcs8 = String(payerPrivatePkcs8B64 || clientPrivatePkcs8B64 || '');
  if (!payerPkcs8) throw new Error('Нужен private key Solana fee payer');
  const payerSeed32 = extractSeed32FromPkcs8B64(payerPkcs8);
  const payerKeypair = solana.Keypair.fromSeed(payerSeed32);
  // Имя clientKeypair сохранено в возвращаемом объекте для совместимости текущих UI-callers;
  // фактически это произвольный fee payer и он не обязан совпадать с ClientKeyBlock.
  return { cleanLogin, endpoint, solana, connection, usersProgram, paymentsProgram, loginGuardProgram, ed25519Program, sysvarInstructions, userPda, economyConfigPda, inflowVault, clientKeypair: payerKeypair, payerKeypair };
}

async function createShineUserPdaOnSolana({
  login,
  keyBundle,
  solanaEndpoint,
  serverAddresses = [],
  isServer = false,
  addressFormatType = 0,
  addressFormatVersion = 0,
  serverAddress = '',
  accessServers = [],
  promoCode = '',
}) {
  const rawLogin = String(login || '').trim();
  const cleanLogin = normalizeLogin(rawLogin);
  const rootKey32 = base64ToBytes(keyBundle.rootPair.publicKeyB64);
  const blockchainKey32 = base64ToBytes(keyBundle.blockchainPair.publicKeyB64);
  const clientKey32 = base64ToBytes(keyBundle.clientPair.publicKeyB64);
  const rootPriv = await importPkcs8Ed25519(keyBundle.rootPair.privatePkcs8B64);
  const bchPriv = await importPkcs8Ed25519(keyBundle.blockchainPair.privatePkcs8B64);
  const ctx = await buildCommonContext({ login: cleanLogin, clientPrivatePkcs8B64: keyBundle.clientPair.privatePkcs8B64, solanaEndpoint });
  const ecoInfo = await ctx.connection.getAccountInfo(ctx.economyConfigPda, 'confirmed');
  if (!ecoInfo?.data) throw new Error('Economy config не инициализирован.');
  const startBonusLimit = parseUsersEconomyConfig(new Uint8Array(ecoInfo.data)).startBonusLimit;
  if (startBonusLimit > 0xffffffffn) throw new Error('Стартовый лимит не помещается в PDA 1.2 u32');
  const createdAtMs = BigInt(Date.now());
  const addresses = normalizeServerAddresses(serverAddresses, isServer ? { addressFormatType, addressFormatVersion, address: serverAddress } : null);
  const initial = {
    login: rawLogin,
    createdAtMs,
    updatedAtMs: createdAtMs,
    recordNumber: 0,
    prevRecordHash: new Uint8Array(32),
    rootKey: rootKey32,
    clientKey: clientKey32,
    forks: [{ blockchainKey: blockchainKey32, createdAtMs, paidLimitBytes: startBonusLimit }],
    serverAddresses: addresses,
    accessServers,
  };
  const unsigned = serializeUnsignedRecordFromState(initial);
  const hash = await sha256Bytes(unsigned);
  const rootSig = await signBytes(rootPriv, hash);
  const recordSig = await signBytes(bchPriv, hash);

  let promoSellerPda = null;
  let promoEdIx = null;
  let promoSellerLogin = '';
  const cleanPromoCode = String(promoCode || '').trim();
  if (cleanPromoCode) {
    const dash = cleanPromoCode.indexOf('-');
    if (!cleanPromoCode.startsWith('1') || dash <= 1 || dash === cleanPromoCode.length - 1) throw new Error('Некорректный формат промокода');
    promoSellerLogin = normalizeLogin(cleanPromoCode.slice(1, dash));
    const sig = base58ToBytes(cleanPromoCode.slice(dash + 1));
    const [sellerPda] = ctx.solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_PROMO_SELLER_PDA_SEED_PREFIX), new TextEncoder().encode(promoSellerLogin)], ctx.usersProgram);
    promoSellerPda = sellerPda;
    const sellerInfo = await ctx.connection.getAccountInfo(sellerPda, 'confirmed');
    if (!sellerInfo?.data || sellerInfo.data.length < 42) throw new Error('Promo seller PDA не найдена');
    promoEdIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(sig, new Uint8Array(sellerInfo.data.slice(10, 42)), buildPromoMessageBytes(cleanLogin)) });
  }

  const ixData = serializeCreateUserPdaArgs({ login: rawLogin, rootKey32, createdAtMs, additionalLimitBytes: 0n, clientKey32, blockchainKey32, serverAddresses: addresses, accessServers, recordSignature64: recordSig, promoSellerLogin });
  const rootIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(rootSig, rootKey32, hash) });
  const recordIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(recordSig, blockchainKey32, hash) });
  const createIx = new ctx.solana.TransactionInstruction({
    programId: ctx.usersProgram,
    keys: [
      { pubkey: ctx.clientKeypair.publicKey, isSigner: true, isWritable: true },
      { pubkey: ctx.userPda, isSigner: false, isWritable: true },
      { pubkey: ctx.solana.SystemProgram.programId, isSigner: false, isWritable: false },
      { pubkey: ctx.inflowVault, isSigner: false, isWritable: true },
      { pubkey: ctx.sysvarInstructions, isSigner: false, isWritable: false },
      { pubkey: ctx.economyConfigPda, isSigner: false, isWritable: false },
      { pubkey: ctx.loginGuardProgram, isSigner: false, isWritable: false },
      ...(promoSellerPda ? [{ pubkey: promoSellerPda, isSigner: false, isWritable: true }] : []),
    ],
    data: ixData,
  });
  try {
    const tx = new ctx.solana.Transaction();
    if (promoEdIx) tx.add(promoEdIx);
    tx.add(rootIx, recordIx, createIx);
    const signature = await ctx.solana.sendAndConfirmTransaction(ctx.connection, tx, [ctx.clientKeypair], { commitment: 'confirmed' });
    return { signature, userPda: ctx.userPda.toBase58(), pdaAddress: ctx.userPda.toBase58(), blockchainName: `${cleanLogin}-001` };
  } catch (error) { throw await attachSolanaLogs(error, ctx.connection); }
}

export async function registerUserOnSolana({ login, keyBundle, solanaEndpoint, accessServers = [], promoCode = '' }) {
  return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, accessServers, promoCode });
}

export async function registerServerOnSolana({ login, keyBundle, serverAddress, serverAddresses = null, addressFormatType = 1, addressFormatVersion = 0, accessServers = [], solanaEndpoint }) {
  return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, isServer: true, serverAddress, serverAddresses: serverAddresses || [], addressFormatType, addressFormatVersion, accessServers });
}

export async function closeLegacyShineUserPdaOnSolana({ login, solanaEndpoint, callerPrivatePkcs8B64 }) {
  const cleanLogin = normalizeLogin(login);
  if (!cleanLogin || !callerPrivatePkcs8B64) throw new Error('Нужны login и private key вызывающего');
  const solana = await loadSolanaLib();
  const endpoint = String(solanaEndpoint || '').trim();
  const connection = new solana.Connection(endpoint, 'confirmed');
  const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID);
  const [userPda] = solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_USER_PDA_SEED_PREFIX), new TextEncoder().encode(cleanLogin)], usersProgram);
  const info = await connection.getAccountInfo(userPda, 'confirmed');
  if (!info) throw new Error('PDA не найдена');
  const raw = new Uint8Array(info.data);
  if (raw.length < 7 || new TextDecoder().decode(raw.slice(0, 5)) !== MAGIC || raw[5] !== FORMAT_MAJOR || raw[6] !== FORMAT_MINOR_LEGACY) {
    throw new Error('Закрывать этой инструкцией можно только legacy PDA 1.0');
  }
  const seed32 = extractSeed32FromPkcs8B64(callerPrivatePkcs8B64);
  const caller = solana.Keypair.fromSeed(seed32);
  const ix = new solana.TransactionInstruction({
    programId: usersProgram,
    keys: [
      { pubkey: caller.publicKey, isSigner: true, isWritable: true },
      { pubkey: userPda, isSigner: false, isWritable: true },
    ],
    data: serializeCloseLegacyArgs(cleanLogin),
  });
  const signature = await solana.sendAndConfirmTransaction(connection, new solana.Transaction().add(ix), [caller], { commitment: 'confirmed' });
  return { signature, pdaAddress: userPda.toBase58() };
}

export async function updateShineUserPdaOnSolana({
  login,
  solanaEndpoint,
  rootPrivatePkcs8B64,
  clientPrivatePkcs8B64,
  payerPrivatePkcs8B64 = '',
  blockchainPrivatePkcs8B64,
  authorityMode,
  additionalLimitBytes = 0n,
  newRootPublicKey32 = null,
  newRootPrivatePkcs8B64 = '',
  nextClientPublicKey32 = null,
  newBlockchainPublicKey32 = null,
  newBlockchainPrivatePkcs8B64 = '',
  serverProfile,
  serverAddresses,
  accessServers,
}) {
  const current = await readShineUserPda({ login, solanaEndpoint });
  const ctx = await buildCommonContext({ login: current.login, clientPrivatePkcs8B64, payerPrivatePkcs8B64, solanaEndpoint });
  const addLimit = BigInt(additionalLimitBytes || 0);
  if (addLimit < 0n || addLimit % LIMIT_STEP !== 0n) throw new Error(`Лимит можно увеличивать только шагом ${LIMIT_STEP}`);
  const authMode = authorityMode === 'blockchain' || authorityMode === AUTH_MODE_BLOCKCHAIN ? AUTH_MODE_BLOCKCHAIN : AUTH_MODE_ROOT;
  const rootKey = newRootPublicKey32 ? toUint8Array(newRootPublicKey32, 32) : current.rootKey;
  const clientKey = nextClientPublicKey32 ? toUint8Array(nextClientPublicKey32, 32) : current.clientKey;
  const rootChanged = bytesToBase58(rootKey) !== bytesToBase58(current.rootKey);
  if (authMode === AUTH_MODE_BLOCKCHAIN && rootChanged) throw new Error('Blockchain authority не может менять root key');
  if (rootChanged && newBlockchainPublicKey32) throw new Error('Root rotation и blockchain fork нужно делать разными транзакциями');

  const updatedAtMs = BigInt(Date.now());
  const forks = current.forks.map((fork) => ({ blockchainKey: fork.blockchainKey, createdAtMs: BigInt(fork.createdAtMs), paidLimitBytes: BigInt(fork.paidLimitBytes) }));
  let appendedKey = null;
  if (newBlockchainPublicKey32) {
    appendedKey = toUint8Array(newBlockchainPublicKey32, 32);
    if (forks.some((f) => bytesToBase58(f.blockchainKey) === bytesToBase58(appendedKey))) throw new Error('Этот blockchain key уже был в истории fork');
    const lastForkAt = BigInt(forks.at(-1).createdAtMs);
    if (authMode === AUTH_MODE_BLOCKCHAIN && updatedAtMs - lastForkAt < FORK_COOLDOWN_MS) throw new Error('Новый fork обычным blockchain authority можно создавать не чаще одного раза в 72 часа');
    const newLimit = forks.at(-1).paidLimitBytes + addLimit;
    if (newLimit > 0xffffffffn) throw new Error('paid_limit_bytes превышает u32');
    forks.push({ blockchainKey: appendedKey, createdAtMs: updatedAtMs, paidLimitBytes: newLimit });
  } else if (addLimit > 0n) {
    const active = forks.at(-1);
    active.paidLimitBytes += addLimit;
    if (active.paidLimitBytes > 0xffffffffn) throw new Error('paid_limit_bytes превышает u32');
  }

  let addresses = current.serverAddresses;
  if (serverAddresses != null) addresses = normalizeServerAddresses(serverAddresses);
  else if (serverProfile != null) {
    if (Array.isArray(serverProfile.addresses)) addresses = normalizeServerAddresses(serverProfile.addresses);
    else if (serverProfile.serverAddress) addresses = normalizeServerAddresses([], { addressFormatType: serverProfile.addressFormatType ?? current.addressFormatType, addressFormatVersion: serverProfile.addressFormatVersion ?? current.addressFormatVersion, address: serverProfile.serverAddress });
    else addresses = [];
  }
  const nextAccess = accessServers == null ? current.accessServers : normalizeAccessServers(accessServers);
  const next = {
    login: current.login,
    createdAtMs: current.createdAtMs,
    updatedAtMs,
    recordNumber: current.recordNumber + 1,
    prevRecordHash: await sha256Bytes(current.unsignedBytes),
    rootKey,
    clientKey,
    forks,
    serverAddresses: addresses,
    accessServers: nextAccess,
  };
  const unsigned = serializeUnsignedRecordFromState(next);
  const hash = await sha256Bytes(unsigned);

  const oldAuthorityPub = authMode === AUTH_MODE_ROOT ? current.rootKey : current.forks.at(-1).blockchainKey;
  const oldAuthorityPrivB64 = authMode === AUTH_MODE_ROOT ? rootPrivatePkcs8B64 : blockchainPrivatePkcs8B64;
  if (!oldAuthorityPrivB64) throw new Error(authMode === AUTH_MODE_ROOT ? 'Нужен root private key' : 'Нужен blockchain private key');
  const oldAuthorityPriv = await importPkcs8Ed25519(oldAuthorityPrivB64);
  const authSig = await signBytes(oldAuthorityPriv, hash);

  let recordSignerPub;
  let recordSignerPrivB64;
  if (rootChanged) {
    recordSignerPub = rootKey;
    recordSignerPrivB64 = newRootPrivatePkcs8B64;
  } else if (appendedKey) {
    recordSignerPub = appendedKey;
    recordSignerPrivB64 = newBlockchainPrivatePkcs8B64;
  } else if (authMode === AUTH_MODE_ROOT) {
    recordSignerPub = rootKey;
    recordSignerPrivB64 = rootPrivatePkcs8B64;
  } else {
    recordSignerPub = current.forks.at(-1).blockchainKey;
    recordSignerPrivB64 = blockchainPrivatePkcs8B64;
  }
  if (!recordSignerPrivB64) throw new Error('Нет приватного ключа нового authority для подписи новой PDA');
  const recordSignerPriv = await importPkcs8Ed25519(recordSignerPrivB64);
  const recordSig = await signBytes(recordSignerPriv, hash);

  const authIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(authSig, oldAuthorityPub, hash) });
  const recordIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(recordSig, recordSignerPub, hash) });
  const updateIx = new ctx.solana.TransactionInstruction({
    programId: ctx.usersProgram,
    keys: [
      { pubkey: ctx.clientKeypair.publicKey, isSigner: true, isWritable: true },
      { pubkey: ctx.userPda, isSigner: false, isWritable: true },
      { pubkey: ctx.solana.SystemProgram.programId, isSigner: false, isWritable: false },
      { pubkey: ctx.inflowVault, isSigner: false, isWritable: true },
      { pubkey: ctx.sysvarInstructions, isSigner: false, isWritable: false },
      { pubkey: ctx.economyConfigPda, isSigner: false, isWritable: false },
    ],
    data: serializeUpdateUserPdaArgs({ login: current.login, rootKey32: rootKey, updatedAtMs, additionalLimitBytes: addLimit, clientKey32: clientKey, authMode, newBlockchainKey32: appendedKey, serverAddresses: addresses, accessServers: nextAccess, recordSignature64: recordSig }),
  });
  try {
    const signature = await ctx.solana.sendAndConfirmTransaction(ctx.connection, new ctx.solana.Transaction().add(authIx, recordIx, updateIx), [ctx.clientKeypair], { commitment: 'confirmed' });
    return { signature, userPda: ctx.userPda.toBase58(), pdaAddress: ctx.userPda.toBase58(), paidLimitBytes: forks.at(-1).paidLimitBytes, forkCount: forks.length };
  } catch (error) { throw await attachSolanaLogs(error, ctx.connection); }
}

export async function updateServerOnSolana({ login, keyBundle, serverAddress, serverAddresses = null, addressFormatType = 1, addressFormatVersion = 0, solanaEndpoint }) {
  return updateShineUserPdaOnSolana({
    login,
    solanaEndpoint,
    rootPrivatePkcs8B64: keyBundle.rootPair.privatePkcs8B64,
    clientPrivatePkcs8B64: keyBundle.clientPair.privatePkcs8B64,
    authorityMode: 'root',
    serverAddresses: serverAddresses || [{ addressFormatType, addressFormatVersion, address: serverAddress }],
  });
}

export function calcLimitTopupPriceLamports(additionalLimitBytes, lamportsPerLimitStep) {
  const add = BigInt(additionalLimitBytes || 0);
  const pricePerStep = BigInt(lamportsPerLimitStep || 0);
  if (add < 0n || add % LIMIT_STEP !== 0n) throw new Error(`Увеличение лимита должно быть кратно ${LIMIT_STEP} байт`);
  return (add / LIMIT_STEP) * pricePerStep;
}

export function getLimitStepBytes() { return LIMIT_STEP; }