// Node.js + Express 기반 간단한 결제 API 예시
const express = require('express');
const router = express.Router();

// 결제 요청 처리
router.post('/payment', async (req, res) => {
  try {
    const { userId, amount, paymentMethod } = req.body;
    
    // 1. 입력 검증
    if (!userId || !amount || amount <= 0) {
      return res.status(400).json({ 
        error: '잘못된 요청입니다' 
      });
    }
    
    // 2. 사용자 잔액 확인
    const userBalance = await checkUserBalance(userId);
    if (userBalance < amount) {
      return res.status(400).json({ 
        error: '잔액이 부족합니다' 
      });
    }
    
    // 3. 트랜잭션 시작
    const transaction = await db.transaction();
    
    try {
      // 4. 결제 처리
      await processPayment(userId, amount, paymentMethod, transaction);
      
      // 5. 트랜잭션 커밋
      await transaction.commit();
      
      res.json({ 
        success: true, 
        message: '결제가 완료되었습니다' 
      });
    } catch (error) {
      // 6. 오류 시 롤백
      await transaction.rollback();
      throw error;
    }
    
  } catch (error) {
    console.error('결제 오류:', error);
    res.status(500).json({ 
      error: '결제 처리 중 오류가 발생했습니다' 
    });
  }
});

module.exports = router;

// AES-256 암호화 예시 (Node.js)
const crypto = require('crypto');

class Encryption {
  constructor(secretKey) {
    // 32바이트 키 생성
    this.key = crypto.scryptSync(secretKey, 'salt', 32);
  }
  
  // 데이터 암호화
  encrypt(text) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-cbc', this.key, iv);
    
    let encrypted = cipher.update(text, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    
    // IV와 암호화된 데이터를 함께 반환
    return iv.toString('hex') + ':' + encrypted;
  }
  
  // 데이터 복호화
  decrypt(encryptedData) {
    const parts = encryptedData.split(':');
    const iv = Buffer.from(parts[0], 'hex');
    const encrypted = parts[1];
    
    const decipher = crypto.createDecipheriv('aes-256-cbc', this.key, iv);
    
    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    
    return decrypted;
  }
}

// 사용 예시
const encryption = new Encryption('your-super-secret-key');
const cardNumber = '1234-5678-9012-3456';
const encrypted = encryption.encrypt(cardNumber);
console.log('암호화:', encrypted);

const decrypted = encryption.decrypt(encrypted);
console.log('복호화:', decrypted);

// JWT 기반 인증 예시
const jwt = require('jsonwebtoken');

// 토큰 생성
function generateToken(userId) {
  const payload = {
    userId: userId,
    iat: Date.now()
  };
  
  // Access Token (짧은 유효기간)
  const accessToken = jwt.sign(
    payload, 
    process.env.JWT_SECRET,
    { expiresIn: '15m' }
  );
  
  // Refresh Token (긴 유효기간)
  const refreshToken = jwt.sign(
    payload,
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: '7d' }
  );
  
  return { accessToken, refreshToken };
}

// 토큰 검증 미들웨어
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: '인증 토큰이 없습니다' });
  }
  
  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: '유효하지 않은 토큰입니다' });
    }
    
    req.user = user;
    next();
  });
}

// 보호된 라우트 예시
app.get('/api/account/balance', authenticateToken, async (req, res) => {
  const balance = await getBalance(req.user.userId);
  res.json({ balance });
});

// Express Rate Limiting 예시
const rateLimit = require('express-rate-limit');

// 일반 API 제한
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100회 요청
  message: '너무 많은 요청을 보냈습니다. 잠시 후 다시 시도해주세요.'
});

// 로그인 API는 더 엄격하게
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 5, // 15분에 5번만
  skipSuccessfulRequests: true, // 성공한 요청은 카운트 안 함
  message: '로그인 시도 횟수를 초과했습니다.'
});

app.use('/api/', apiLimiter);
app.post('/api/auth/login', loginLimiter, loginHandler);

// 입력 검증 예시
const { body, validationResult } = require('express-validator');

app.post('/api/transfer',
  [
    body('recipientAccount').isNumeric().isLength({ min: 10, max: 14 }),
    body('amount').isFloat({ min: 1, max: 10000000 }),
    body('memo').optional().trim().escape()
  ],
  (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    
    // 송금 처리...
  }
);

// 토스페이먼츠 결제 연동 예시 (간소화)
const axios = require('axios');

class TossPayments {
  constructor(secretKey) {
    this.secretKey = secretKey;
    this.baseURL = 'https://api.tosspayments.com/v1';
  }
  
  // 결제 승인
  async confirmPayment(paymentKey, orderId, amount) {
    try {
      const response = await axios.post(
        `${this.baseURL}/payments/confirm`,
        {
          paymentKey,
          orderId,
          amount
        },
        {
          headers: {
            'Authorization': `Basic ${Buffer.from(this.secretKey + ':').toString('base64')}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      return {
        success: true,
        data: response.data
      };
      
    } catch (error) {
      console.error('결제 승인 실패:', error.response?.data);
      return {
        success: false,
        error: error.response?.data?.message || '결제 처리 중 오류가 발생했습니다'
      };
    }
  }
  
  // 결제 취소
  async cancelPayment(paymentKey, cancelReason) {
    try {
      const response = await axios.post(
        `${this.baseURL}/payments/${paymentKey}/cancel`,
        { cancelReason },
        {
          headers: {
            'Authorization': `Basic ${Buffer.from(this.secretKey + ':').toString('base64')}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      return {
        success: true,
        data: response.data
      };
      
    } catch (error) {
      return {
        success: false,
        error: error.response?.data?.message
      };
    }
  }
}

// 사용 예시
const toss = new TossPayments(process.env.TOSS_SECRET_KEY);

app.post('/api/payment/confirm', async (req, res) => {
  const { paymentKey, orderId, amount } = req.body;
  
  // 주문 정보 검증
  const order = await getOrder(orderId);
  if (!order || order.amount !== amount) {
    return res.status(400).json({ error: '주문 정보가 일치하지 않습니다' });
  }
  
  // 결제 승인
  const result = await toss.confirmPayment(paymentKey, orderId, amount);
  
  if (result.success) {
    // DB에 결제 정보 저장
    await savePaymentInfo(result.data);
    res.json({ success: true, payment: result.data });
  } else {
    res.status(400).json({ error: result.error });
  }
});

-- 안전한 송금 프로시저 예시 (PostgreSQL)
CREATE OR REPLACE FUNCTION transfer_money(
  p_from_account_id BIGINT,
  p_to_account_id BIGINT,
  p_amount DECIMAL(19, 4),
  p_description TEXT
) RETURNS BIGINT AS $$
DECLARE
  v_transaction_id BIGINT;
  v_from_balance DECIMAL(19, 4);
BEGIN
  -- 트랜잭션 시작 (함수 호출 시 자동)
  
  -- 송금 계좌 잠금 및 잔액 확인
  SELECT balance INTO v_from_balance
  FROM accounts
  WHERE account_id = p_from_account_id
  FOR UPDATE;  -- 행 잠금!
  
  -- 잔액 부족 체크
  IF v_from_balance < p_amount THEN
    RAISE EXCEPTION '잔액이 부족합니다';
  END IF;
  
  -- 송금 계좌 차감
  UPDATE accounts
  SET balance = balance - p_amount,
      updated_at = NOW()
  WHERE account_id = p_from_account_id;
  
  -- 수취 계좌 증가
  UPDATE accounts
  SET balance = balance + p_amount,
      updated_at = NOW()
  WHERE account_id = p_to_account_id;
  
  -- 거래 내역 기록
  INSERT INTO transactions (
    from_account_id,
    to_account_id,
    amount,
    description,
    status,
    created_at
  ) VALUES (
    p_from_account_id,
    p_to_account_id,
    p_amount,
    p_description,
    'COMPLETED',
    NOW()
  ) RETURNING transaction_id INTO v_transaction_id;
  
  RETURN v_transaction_id;
  
EXCEPTION
  WHEN OTHERS THEN
    -- 오류 발생 시 자동 롤백
    RAISE;
END;
$$ LANGUAGE plpgsql;

// Jest를 이용한 결제 로직 단위 테스트 예시
describe('Payment Service', () => {
  let paymentService;
  let mockDB;
  
  beforeEach(() => {
    mockDB = {
      getAccount: jest.fn(),
      updateBalance: jest.fn(),
      createTransaction: jest.fn()
    };
    paymentService = new PaymentService(mockDB);
  });
  
  test('잔액이 충분할 때 송금 성공', async () => {
    // Given
    mockDB.getAccount.mockResolvedValue({
      id: 1,
      balance: 10000
    });
    
    // When
    const result = await paymentService.transfer({
      fromAccountId: 1,
      toAccountId: 2,
      amount: 5000
    });
    
    // Then
    expect(result.success).toBe(true);
    expect(mockDB.updateBalance).toHaveBeenCalledTimes(2);
    expect(mockDB.createTransaction).toHaveBeenCalled();
  });
  
  test('잔액 부족 시 송금 실패', async () => {
    // Given
    mockDB.getAccount.mockResolvedValue({
      id: 1,
      balance: 3000
    });
    
    // When & Then
    await expect(
      paymentService.transfer({
        fromAccountId: 1,
        toAccountId: 2,
        amount: 5000
      })
    ).rejects.toThrow('잔액이 부족합니다');
    
    expect(mockDB.updateBalance).not.toHaveBeenCalled();
  });
  
  test('음수 금액 송금 시도 시 에러', async () => {
    // When & Then
    await expect(
      paymentService.transfer({
        fromAccountId: 1,
        toAccountId: 2,
        amount: -1000
      })
    ).rejects.toThrow('유효하지 않은 금액입니다');
  });
  
  test('동일 계좌로 송금 시도 시 에러', async () => {
    // When & Then
    await expect(
      paymentService.transfer({
        fromAccountId: 1,
        toAccountId: 1,
        amount: 5000
      })
    ).rejects.toThrow('동일한 계좌로는 송금할 수 없습니다');
  });
});

# GitHub Actions CI/CD 예시 (.github/workflows/deploy.yml)
name: Deploy to Production

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test
      
      - name: Run security audit
        run: npm audit --audit-level=high
  
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Build Docker image
        run: docker build -t myapp:${{ github.sha }} .
      
      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker push myapp:${{ github.sha }}
  
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to Kubernetes
        run: |
          kubectl set image deployment/myapp myapp=myapp:${{ github.sha }}
          kubectl rollout status deployment/myapp

// React Native i18n 예시 (react-i18next)
import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';

const resources = {
  ko: {
    translation: {
      "welcome": "환영합니다",
      "balance": "잔액",
      "transfer": "송금하기",
      "amount": "{{amount}}원"
    }
  },
  en: {
    translation: {
      "welcome": "Welcome",
      "balance": "Balance",
      "transfer": "Transfer",
      "amount": "${{amount}}"
    }
  },
  ja: {
    translation: {
      "welcome": "ようこそ",
      "balance": "残高",
      "transfer": "送金",
      "amount": "{{amount}}円"
    }
  }
};

i18n
  .use(initReactI18next)
  .init({
    resources,
    lng: 'ko', // 기본 언어
    fallbackLng: 'en',
    interpolation: {
      escapeValue: false
    }
  });

// 사용 예시
import { useTranslation } from 'react-i18next';

function BalanceScreen() {
  const { t, i18n } = useTranslation();
  const balance = 1000000;
  
  return (
    <View>
      <Text>{t('welcome')}</Text>
      <Text>{t('balance')}: {t('amount', { amount: balance.toLocaleString(i18n.language) })}</Text>
    </View>
  );
}