curl -X POST "https://api.telegram.org/bot{BOT_TOKEN}/setWebhook" \
     -H "Content-Type: application/json" \
     -d '{
       "url": "https://your-domain.com/api/webhook",
       "allowed_updates": ["message", "photo"],
       "drop_pending_updates": true
     }'

curl "https://api.telegram.org/bot{BOT_TOKEN}/getWebhookInfo"

# Telegram Configuration
telegram:
  bot:
    token: ${TELEGRAM_BOT_TOKEN}
    webhook-url: ${TELEGRAM_WEBHOOK_URL:https://your-domain.com/api/webhook}
    username: ${TELEGRAM_BOT_USERNAME:artivisi_accounting_bot}

# File Storage Configuration
storage:
  type: ${STORAGE_TYPE:local}
  local-path: ${STORAGE_LOCAL_PATH:/var/accounting/receipts}
  max-file-size: ${STORAGE_MAX_FILE_SIZE:10MB}

# Security Configuration
security:
  allowed-users: ${ALLOWED_TELEGRAM_USERS:}
  webhook-secret: ${TELEGRAM_WEBHOOK_SECRET}

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Telegram Bot API -->
    <dependency>
        <groupId>org.telegram</groupId>
        <artifactId>telegrambots-springboot-longpolling-starter</artifactId>
        <version>6.9.7.1</version>
    </dependency>

    <!-- File Upload -->
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.5</version>
    </dependency>

    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
</dependencies>

@RestController
@RequestMapping("/api/webhook")
@RequiredArgsConstructor
@Slf4j
public class TelegramWebhookController {

    private final TelegramService telegramService;
    private final OCRService ocrService;
    private final AccountingService accountingService;

    @PostMapping
    public ResponseEntity<Void> handleTelegramUpdate(
            @RequestBody Update update,
            @RequestHeader(value = "X-Telegram-Bot-Api-Secret-Token", required = false) String secret) {

        // Validasi webhook secret (security)
        if (!telegramService.validateWebhookSecret(secret)) {
            log.warn("Invalid webhook secret from IP: {}", getClientIP());
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }

        try {
            if (update.hasMessage() && update.getMessage().hasPhoto()) {
                Message message = update.getMessage();
                log.info("Received photo from user: {}", message.getFrom().getUserName());

                // Proses foto asynchronously untuk respons yang cepat
                CompletableFuture.runAsync(() -> processPhotoMessage(message));

            } else if (update.hasMessage()) {
                Message message = update.getMessage();
                log.info("Received text message: {}", message.getText());
                handleTextMessage(message);
            }

            return ResponseEntity.ok().build();

        } catch (Exception e) {
            log.error("Error processing Telegram update", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    private void processPhotoMessage(Message message) {
        try {
            // Download foto dari server Telegram
            String imageUrl = telegramService.downloadPhoto(message.getPhoto());

            // Simpan file ke local storage
            String localFilePath = telegramService.savePhotoLocally(imageUrl, message.getMessageId());

            // Kirim konfirmasi ke user
            telegramService.sendMessage(message.getChatId(),
                "📸 Foto struk diterima. Sedang diproses OCR...");

            // Proses OCR
            OCRResult ocrResult = ocrService.extractTextFromImage(localFilePath);

            // Parsing dan buat transaksi
            InvoiceData invoiceData = ocrService.parseInvoiceData(ocrResult.getText());
            Invoice invoice = accountingService.createDraftInvoice(invoiceData, localFilePath, message);

            // Kirim hasil ke user
            sendOCRResult(message.getChatId(), ocrResult, invoice);

        } catch (Exception e) {
            log.error("Error processing photo message", e);
            telegramService.sendMessage(message.getChatId(),
                "❌ Maaf, terjadi kesalahan saat memproses foto. Silakan coba lagi.");
        }
    }

    private void sendOCRResult(Long chatId, OCRResult ocrResult, Invoice invoice) {
        String message = String.format("""
            ✅ **OCR Selesai!**

            📝 **Hasil Ekstraksi:**
            %s

            💰 **Total:** %s
            📅 **Tanggal:** %s
            🏪 **Merchant:** %s

            📋 **Transaksi #%d** sudah dibuat dengan status DRAFT.
            Silakan review dan posting di aplikasi web.
            """,
            truncateText(ocrResult.getText(), 200),
            invoice.getTotalAmount(),
            invoice.getTransactionDate(),
            invoice.getMerchantName(),
            invoice.getId()
        );

        telegramService.sendMessage(chatId, message);
    }
}

@Service
@RequiredArgsConstructor
public class TelegramAuthService {

    private final UserRepository userRepository;
    private final TelegramUserService telegramUserService;

    @Transactional
    public AuthResult authenticateUser(Message message) {
        User telegramUser = message.getFrom();
        Long chatId = message.getChatId();

        // Cek user sudah terdaftar atau belum
        Optional<UserAccount> existingUser = userRepository.findByTelegramUserId(telegramUser.getId());

        if (existingUser.isEmpty()) {
            // User baru, generate auth code
            String authCode = generateAuthCode();

            // Simpan temporary registration
            telegramUserService.savePendingRegistration(telegramUser, chatId, authCode);

            // Kirim instruksi registrasi
            String welcomeMessage = String.format("""
                👋 Selamat datang %s!

                Akun Telegram Anda belum terdaftar di sistem akunting.

                📝 **Kode Verifikasi:** `%s`

                Silakan masuk ke aplikasi web dan masukkan kode verifikasi di atas untuk menyelesaikan registrasi.

                ⏰ Kode berlaku selama 10 menit.
                """, telegramUser.getFirstName(), authCode);

            return AuthResult.pendingRegistration(welcomeMessage);
        }

        // User sudah terdaftar, update chat ID
        UserAccount userAccount = existingUser.get();
        userAccount.setTelegramChatId(chatId);
        userAccount.setLastTelegramAccess(LocalDateTime.now());
        userRepository.save(userAccount);

        return AuthResult.success("✅ Autentikasi berhasil. Silakan kirim foto struk transaksi.");
    }

    private String generateAuthCode() {
        return String.format("%06d", new Random().nextInt(999999));
    }
}

@RestController
@RequestMapping("/api/auth/telegram")
@RequiredArgsConstructor
public class TelegramAuthController {

    private final TelegramAuthService telegramAuthService;

    @PostMapping("/register")
    public ResponseEntity<ApiResponse> registerTelegramAccount(@RequestBody TelegramRegistrationRequest request) {
        try {
            UserAccount user = telegramAuthService.completeRegistration(
                request.getAuthCode(),
                request.getEmail(),
                request.getPassword()
            );

            return ResponseEntity.ok(ApiResponse.success(
                "Registrasi berhasil. Akun Telegram Anda terhubung.",
                user));

        } catch (InvalidAuthCodeException e) {
            return ResponseEntity.badRequest()
                .body(ApiResponse.error("Kode verifikasi tidak valid atau kadaluarsa."));

        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(ApiResponse.error("Registrasi gagal. Silakan coba lagi."));
        }
    }

    @PostMapping("/link")
    public ResponseEntity<ApiResponse> linkTelegramAccount(@RequestBody TelegramLinkRequest request) {
        try {
            UserAccount user = telegramAuthService.linkTelegramAccount(
                request.getEmail(),
                request.getPassword(),
                request.getAuthCode()
            );

            return ResponseEntity.ok(ApiResponse.success(
                "Akun Telegram berhasil dihubungkan.",
                user));

        } catch (AuthenticationException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                .body(ApiResponse.error("Email atau password salah."));
        }
    }
}

{
  "type": "service_account",
  "project_id": "artivisi-accounting-ocr",
  "private_key_id": "abcdef123456...",
  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
  "client_email": "accounting-ocr-service@artivisi-accounting-ocr.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/accounting-ocr-service%40artivisi-accounting-ocr.iam.gserviceaccount.com"
}

<!-- Google Cloud Vision -->
<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-vision</artifactId>
    <version>3.15.0</version>
</dependency>

<!-- Google Cloud Storage (untuk file handling) -->
<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-storage</artifactId>
    <version>2.27.1</version>
</dependency>

google:
  cloud:
    project-id: ${GOOGLE_CLOUD_PROJECT_ID:artivisi-accounting-ocr}
    credentials:
      path: ${GOOGLE_APPLICATION_CREDENTIALS:/app/credentials/service-account.json}
    vision:
      endpoint: ${GOOGLE_VISION_API_ENDPOINT:https://vision.googleapis.com}
      max-requests-per-second: ${GOOGLE_VISION_RATE_LIMIT:10}

# Rate limiting untuk Google Cloud Vision
ratelimit:
  google-vision:
    requests-per-minute: ${GOOGLE_VISION_RPM:600}
    requests-per-second: ${GOOGLE_VISION_RPS:10}

# Development
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json"
export GOOGLE_CLOUD_PROJECT_ID="artivisi-accounting-ocr"

# Production (dalam docker-compose.yml)
environment:
  - GOOGLE_APPLICATION_CREDENTIALS=/app/credentials/service-account.json
  - GOOGLE_CLOUD_PROJECT_ID=${GOOGLE_CLOUD_PROJECT_ID}

@Service
@RequiredArgsConstructor
@Slf4j
public class GoogleVisionOCRService {

    private final VisionConfig visionConfig;
    private final RateLimiter rateLimiter;

    public OCRResult extractTextFromImage(String imageFilePath) throws OCRProcessingException {
        try {
            // Rate limiting untuk menghindari quota exceeded
            rateLimiter.acquire();

            // Initialize Vision Client
            ImageAnnotatorClient visionClient = createVisionClient();

            // Load image
            ByteString imgBytes = ByteString.readFrom(new FileInputStream(imageFilePath));
            Image image = Image.newBuilder().setContent(imgBytes).build();

            // Build request untuk text detection
            Feature textFeature = Feature.newBuilder()
                .setType(Feature.Type.TEXT_DETECTION)
                .build();

            AnnotateImageRequest request = AnnotateImageRequest.newBuilder()
                .addFeatures(textFeature)
                .setImage(image)
                .build();

            // Execute OCR
            List<AnnotateImageRequest> requests = Arrays.asList(request);
            BatchAnnotateImagesResponse response = visionClient.batchAnnotateImages(requests);

            // Process results
            List<EntityAnnotation> textAnnotations = response.getResponsesList().get(0).getTextAnnotationsList();

            if (textAnnotations.isEmpty()) {
                log.warn("No text detected in image: {}", imageFilePath);
                return OCRResult.empty("No text detected in the image");
            }

            // Full text adalah annotation pertama
            String extractedText = textAnnotations.get(0).getDescription();

            // Confidence score
            float confidence = textAnnotations.get(0).getScore();

            log.info("OCR completed for file: {}, text length: {}, confidence: {}",
                imageFilePath, extractedText.length(), confidence);

            return OCRResult.builder()
                .text(extractedText)
                .confidence(confidence)
                .processingTime(System.currentTimeMillis())
                .source(imageFilePath)
                .build();

        } catch (IOException e) {
            throw new OCRProcessingException("Failed to read image file: " + imageFilePath, e);
        } catch (GoogleApiException e) {
            throw new OCRProcessingException("Google Cloud Vision API error: " + e.getMessage(), e);
        } finally {
            rateLimiter.release();
        }
    }

    private ImageAnnotatorClient createVisionClient() throws IOException {
        try {
            if (visionConfig.getCredentialsPath() != null) {
                // Use service account key file
                Credentials credentials = GoogleCredentials.fromStream(
                    new FileInputStream(visionConfig.getCredentialsPath())
                );

                return ImageAnnotatorClient.create(
                    ImageAnnotatorSettings.newBuilder()
                        .setCredentialsProvider(FixedCredentialsProvider.create(credentials))
                        .setEndpoint(visionConfig.getEndpoint())
                        .build()
                );
            } else {
                // Use default credentials (for development)
                return ImageAnnotatorClient.create();
            }
        } catch (Exception e) {
            throw new IOException("Failed to create Vision client", e);
        }
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class OCRDataParsingService {

    private static final Pattern DATE_PATTERN = Pattern.compile(
        "(\\d{2}[/-]\\d{2}[/-]\\d{4}|\\d{4}[/-]\\d{2}[/-]\\d{2})"
    );

    private static final Pattern AMOUNT_PATTERN = Pattern.compile(
        "(Rp\\s*[\\d.,]+| IDR\\s*[\\d.,]+|[\\d.,]+\\s*(ribu|rbu|jt|juta|mily|triliun))"
    );

    private static final Pattern MERCHANT_PATTERN = Pattern.compile(
        "(PT\\s+[A-Z\\s&.]+|CV\\s+[A-Z\\s.]+|[A-Z][a-z]+\\s+(Store|Shop|Mart|Market|Indo|Indonesia))"
    );

    public InvoiceData parseInvoiceData(String ocrText) {
        log.debug("Parsing OCR text (length: {})", ocrText.length());

        InvoiceData.InvoiceDataBuilder builder = InvoiceData.builder();

        // Parse tanggal transaksi
        LocalDate transactionDate = extractTransactionDate(ocrText);
        if (transactionDate != null) {
            builder.transactionDate(transactionDate);
        }

        // Parse amount/total
        BigDecimal totalAmount = extractTotalAmount(ocrText);
        if (totalAmount != null) {
            builder.totalAmount(totalAmount);
        }

        // Parse merchant name
        String merchantName = extractMerchantName(ocrText);
        if (merchantName != null) {
            builder.merchantName(merchantName);
        }

        // Parse payment method
        String paymentMethod = extractPaymentMethod(ocrText);
        if (paymentMethod != null) {
            builder.paymentMethod(paymentMethod);
        }

        // Parse description
        String description = extractDescription(ocrText);
        builder.description(description);

        // Extract tax amount if any
        BigDecimal taxAmount = extractTaxAmount(ocrText, totalAmount);
        if (taxAmount != null) {
            builder.taxAmount(taxAmount);
        }

        InvoiceData result = builder.build();
        log.info("Parsed invoice data: {}", result);

        return result;
    }

    private LocalDate extractTransactionDate(String text) {
        Matcher matcher = DATE_PATTERN.matcher(text);
        if (matcher.find()) {
            String dateStr = matcher.group(1);
            try {
                // Try various date formats
                String[] formats = {"dd/MM/yyyy", "dd-MM-yyyy", "yyyy/MM/dd", "yyyy-MM-dd"};

                for (String format : formats) {
                    try {
                        return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(format));
                    } catch (DateTimeParseException ignored) {
                        // Try next format
                    }
                }
            } catch (Exception e) {
                log.warn("Failed to parse date: {}", dateStr);
            }
        }
        return null;
    }

    private BigDecimal extractTotalAmount(String text) {
        // Clean the text first
        String cleanText = text.replaceAll("[^\\d.,RpIDR]", " ");

        Matcher matcher = AMOUNT_PATTERN.matcher(cleanText);
        BigDecimal maxAmount = null;

        while (matcher.find()) {
            String amountStr = matcher.group(1);

            try {
                BigDecimal amount = parseAmount(amountStr);
                if (amount != null && (maxAmount == null || amount.compareTo(maxAmount) > 0)) {
                    maxAmount = amount;
                }
            } catch (Exception e) {
                log.debug("Failed to parse amount: {}", amountStr);
            }
        }

        return maxAmount;
    }

    private BigDecimal parseAmount(String amountStr) {
        // Remove currency symbols and spaces
        String numericStr = amountStr.replaceAll("[^\\d.,]", "").trim();

        // Handle Indonesian abbreviations
        if (amountStr.contains("ribu") || amountStr.contains("rbu")) {
            numericStr = numericStr.replaceAll("[.,]", "");
            return new BigDecimal(numericStr).multiply(new BigDecimal("1000"));
        } else if (amountStr.contains("jt") || amountStr.contains("juta")) {
            numericStr = numericStr.replaceAll("[.,]", "");
            return new BigDecimal(numericStr).multiply(new BigDecimal("1000000"));
        } else if (amountStr.contains("mily")) {
            numericStr = numericStr.replaceAll("[.,]", "");
            return new BigDecimal(numericStr).multiply(new BigDecimal("1000000000"));
        }

        // Standard decimal parsing
        numericStr = numericStr.replaceAll("[,]", "");
        try {
            return new BigDecimal(numericStr);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    private String extractMerchantName(String text) {
        // Look for common merchant patterns
        List<String> merchantKeywords = Arrays.asList(
            "PT ", "CV ", "PD ", "UD ", "F&B", "ALFAMART", "INDOMARET",
            "BANK", "BCA", "BNI", "BRI", "MANDIRI", "DANAMON",
            "TELUK", "PERTAMINA", "SHELL", "PETRONAS"
        );

        String[] lines = text.split("\\r?\\n");
        for (String line : lines) {
            line = line.trim();
            if (line.length() > 3 && line.length() < 50) {
                for (String keyword : merchantKeywords) {
                    if (line.toUpperCase().contains(keyword)) {
                        return line.trim();
                    }
                }
            }
        }

        // Fallback: look for capitalized words in first few lines
        String[] firstLines = Arrays.copyOf(lines, Math.min(5, lines.length));
        for (String line : firstLines) {
            if (line.matches(".*[A-Z][a-z]+.*") && line.length() < 50) {
                return line.trim();
            }
        }

        return null;
    }

    private String extractPaymentMethod(String text) {
        String upperText = text.toUpperCase();

        if (upperText.contains("QRIS") || upperText.contains("QR CODE")) {
            return "QRIS";
        } else if (upperText.contains("DEBIT")) {
            return "Debit Card";
        } else if (upperText.contains("KREDIT") || upperText.contains("CREDIT")) {
            return "Credit Card";
        } else if (upperText.contains("TUNAI") || upperText.contains("CASH")) {
            return "Cash";
        } else if (upperText.contains("TRANSFER") || upperText.contains("VA")) {
            return "Transfer";
        }

        return null;
    }

    private String extractDescription(String text) {
        // Extract first meaningful line as description
        String[] lines = text.split("\\r?\\n");
        for (String line : lines) {
            line = line.trim();
            if (line.length() > 5 && line.length() < 100) {
                // Skip lines that look like amounts or dates
                if (!line.matches(".*\\d+.*") || !line.contains("Rp")) {
                    return line;
                }
            }
        }
        return null;
    }

    private BigDecimal extractTaxAmount(String text, BigDecimal totalAmount) {
        // Look for tax indicators
        if (text.toUpperCase().contains("PPN") || text.toUpperCase().contains("TAX")) {
            // Assume 11% tax rate (Indonesia)
            return totalAmount.multiply(new BigDecimal("0.11"));
        }
        return null;
    }
}

@Service
@RequiredArgsConstructor
public class AccountingTransactionService {

    private final InvoiceRepository invoiceRepository;
    private final OCRDataParsingService ocrParsingService;

    @Transactional
    public Invoice createInvoiceFromOCR(OCRResult ocrResult, String imageFilePath, Message telegramMessage) {
        try {
            // Parse OCR text to structured data
            InvoiceData invoiceData = ocrParsingService.parseInvoiceData(ocrResult.getText());

            // Create invoice entity
            Invoice invoice = Invoice.builder()
                .merchantName(invoiceData.getMerchantName())
                .transactionDate(invoiceData.getTransactionDate())
                .totalAmount(invoiceData.getTotalAmount())
                .taxAmount(invoiceData.getTaxAmount())
                .paymentMethod(invoiceData.getPaymentMethod())
                .description(invoiceData.getDescription())
                .imageUrl(imageFilePath)
                .telegramMessageId(telegramMessage.getMessageId().toString())
                .telegramUserId(telegramMessage.getFrom().getId())
                .ocrText(ocrResult.getText())
                .ocrConfidence(ocrResult.getConfidence())
                .status(InvoiceStatus.DRAFT)
                .createdAt(LocalDateTime.now())
                .build();

            // Generate journal entries automatically
            List<JournalEntry> journalEntries = generateJournalEntries(invoiceData, invoice);

            invoice.setJournalEntries(journalEntries);

            // Save to database
            Invoice savedInvoice = invoiceRepository.save(invoice);

            log.info("Created invoice from OCR: {}", savedInvoice.getId());
            return savedInvoice;

        } catch (Exception e) {
            log.error("Failed to create invoice from OCR", e);
            throw new TransactionCreationException("Failed to create invoice from OCR", e);
        }
    }

    private List<JournalEntry> generateJournalEntries(InvoiceData invoiceData, Invoice invoice) {
        List<JournalEntry> entries = new ArrayList<>();

        // Determine account codes based on merchant type and description
        String expenseAccount = determineExpenseAccount(invoiceData);
        String taxAccount = "2101"; // PPN Masukan (Tax Payable)

        BigDecimal totalAmount = invoiceData.getTotalAmount();
        BigDecimal taxAmount = invoiceData.getTaxAmount() != null ? invoiceData.getTaxAmount() : BigDecimal.ZERO;
        BigDecimal netAmount = totalAmount.subtract(taxAmount);

        // Debit expense account
        entries.add(JournalEntry.builder()
            .invoice(invoice)
            .accountCode(expenseAccount)
            .accountName(getAccountName(expenseAccount))
            .debit(netAmount)
            .credit(BigDecimal.ZERO)
            .description(invoiceData.getDescription())
            .build());

        // Debit tax account (if any)
        if (taxAmount.compareTo(BigDecimal.ZERO) > 0) {
            entries.add(JournalEntry.builder()
                .invoice(invoice)
                .accountCode(taxAccount)
                .accountName(getAccountName(taxAccount))
                .debit(taxAmount)
                .credit(BigDecimal.ZERO)
                .description("PPN " + invoiceData.getMerchantName())
                .build());
        }

        // Credit cash/bank account
        String paymentAccount = determinePaymentAccount(invoiceData.getPaymentMethod());
        entries.add(JournalEntry.builder()
            .invoice(invoice)
            .accountCode(paymentAccount)
            .accountName(getAccountName(paymentAccount))
            .debit(BigDecimal.ZERO)
            .credit(totalAmount)
            .description(invoiceData.getMerchantName())
            .build());

        return entries;
    }

    private String determineExpenseAccount(InvoiceData invoiceData) {
        String merchantName = invoiceData.getMerchantName();
        String description = invoiceData.getDescription();

        if (merchantName != null) {
            if (merchantName.toUpperCase().contains("PERTAMINA") || merchantName.toUpperCase().contains("SHELL")) {
                return "5101"; // Bahan Bakar Kendaraan
            } else if (merchantName.toUpperCase().contains("ALFAMART") || merchantName.toUpperCase().contains("INDOMARET")) {
                return "5102"; // ATK dan Perlengkapan Kantor
            } else if (merchantName.toUpperCase().contains("RESTAURANT") || merchantName.toUpperCase().contains("CAFE")) {
                return "5103"; // Entertainment & representasi
            }
        }

        return "5104"; // Biaya Operasional Lainnya
    }

    private String determinePaymentAccount(String paymentMethod) {
        if ("QRIS".equals(paymentMethod) || "Transfer".equals(paymentMethod)) {
            return "1102"; // Bank BCA
        } else if ("Cash".equals(paymentMethod)) {
            return "1101"; // Kas
        }
        return "1102"; // Default to bank account
    }
}