"""
Auto-generated Skill

Skill ID: lihat_keranjang
Version: v1

Inputs:
Tidak ada input yang diperlukan dari pengguna. Skill ini akan langsung memproses dan menampilkan isi keranjang belanja.

Outputs:
- daftar produk di keranjang (nama, kuantitas, harga per unit)
- total harga keseluruhan
- jumlah total item di keranjang

Side Effects:
Tidak ada efek samping yang terjadi. Skill ini hanya mengambil dan menampilkan informasi keranjang belanja tanpa memodifikasinya.

[WARNING] GENERATED CODE — DO NOT EDIT MANUALLY

## Supported Output Types

The `run()` function should return a dict with these fields:

### Required:
- status: "SUCCESS" | "FAILED" | "ERROR"
- message: Human-readable summary

### Optional Rich Outputs (UI will render these):
- output: Plain text response
- data: Any structured data (dict)
- table: {{headers: [...], rows: [[...], [...]]}}
- file: {{name: "file.pdf", path: "/path", mime: "application/pdf", size: "1.2 MB"}}
- image: {{url: "/static/img.png", caption: "Description", alt: "Alt text"}}
- chart: {{type: "bar", title: "Title", labels: [...], datasets: [{{label: "A", data: [...]}}]}}
- actions: [{{id: "action_id", label: "Button Text", style: "primary|secondary|success|danger"}}]
"""

from typing import Dict, Any


def validate_inputs(inputs: Dict[str, Any]) -> None:
    """
    Validate required inputs.
    Raise ValueError if invalid.
    """
    if not isinstance(inputs, dict):
        raise ValueError("Inputs harus berupa kamus (dictionary).")
    # No specific inputs are required for this skill, so no further validation is needed.


def run(inputs: Dict[str, Any]) -> Dict[str, Any]:
    """
    Single entrypoint for this skill.
    """
    result = {
        "status": "ERROR", # Default to ERROR, will be updated based on logic
        "message": "Terjadi kesalahan yang tidak terduga.",
        "data": { "skill_id": "lihat_keranjang", "version": "v1" }
    }

    try:
        validate_inputs(inputs)
    except ValueError as e:
        result["status"] = "ERROR"
        result["message"] = str(e)
        return result

    try:
        # Import mcp_runtime INSIDE run() as per pattern
        from agent import mcp_runtime

        # Logic Step 1: Panggil alat `view_cart` tanpa parameter
        tool_result = mcp_runtime.execute_tool(
            "remote_service",
            "view_cart",
            {} # No parameters required for view_cart
        )

        # Defensive check for tool execution issues (e.g., network errors, malformed response before JSON parsing)
        if isinstance(tool_result, str):
            result["status"] = "FAILED"
            result["message"] = f"Gagal mengambil keranjang belanja karena masalah eksekusi alat: {tool_result}"
            return result
        
        # Logic Step 2: Periksa respons dari `view_cart`
        error_field = tool_result.get('error')

        # Logic Step 2a: Jika `response.error.status` adalah `true`
        if error_field: 
            if isinstance(error_field, dict) and error_field.get('status') is True:
                error_msg = error_field.get('msg', "Gagal mengambil keranjang belanja karena kesalahan API yang tidak diketahui.")
                result["status"] = "FAILED"
                result["message"] = f"Gagal mengambil keranjang belanja: {error_msg}"
                return result
            elif isinstance(error_field, str): # Handle error as a plain string
                result["status"] = "FAILED"
                result["message"] = f"Gagal mengambil keranjang belanja: {error_field}"
                return result
        
        # Adhering strictly to Skill Contract logic for extracting cart items:
        # "Parsing respons dari alat `view_cart` akan menggunakan `response.table.rows` untuk mengekstrak item keranjang, 
        # bukan `response.data.detail` yang mungkin tertera di dokumentasi alat. 
        # Jika `response.table.rows` ditemukan kosong atau tidak terdefinisi, keranjang belanja akan dianggap kosong."
        cart_items_from_tool_response = tool_result.get('table', {}).get('rows')

        # Logic Step 2a: Jika `response.table.rows` kosong/tidak terdefinisi
        if not cart_items_from_tool_response:
            result["status"] = "SUCCESS"
            empty_cart_message = 'Keranjang belanja Anda kosong. Silahkan memilih produk terlebih dahulu.'
            result["message"] = empty_cart_message
            result["output"] = empty_cart_message
            # No table or additional data needed for an empty cart.
            return result
        
        # Logic Step 2b: Jika `response.table.rows` berisi data produk
        # Logic Step 2b.i: Inisialisasi `total_harga_keseluruhan` menjadi 0.
        total_harga_keseluruhan = 0.0
        # Logic Step 2b.ii: Inisialisasi `jumlah_total_item_di_keranjang` menjadi 0.
        jumlah_total_item_di_keranjang = 0
        # Logic Step 2b.iii: Inisialisasi daftar kosong `produk_keranjang_untuk_tabel`.
        produk_keranjang_untuk_tabel_data = [] # To store processed data for table and result["data"]

        # Logic Step 2b.iv: Iterasi setiap `item` dalam `response.table.rows`
        # The contract indicates keys like 'Product Name', 'Quantity', 'Price' in `item`.
        # This implies `cart_items_from_tool_response` is a list of dictionaries.
        
        for item in cart_items_from_tool_response:
            try:
                # Logic Step 2b.iv.1: Ekstrak `Nama Produk`, `Kuantitas`, dan `Harga`.
                product_name = str(item.get('Product Name', 'N/A'))
                
                qty_raw = item.get('Quantity')
                price_raw = item.get('Price')

                # Logic Step 2b.iv.2: Konversi `Harga` dan `Kuantitas` ke format angka.
                try:
                    qty = int(qty_raw)
                except (ValueError, TypeError):
                    qty = 0 # Default to 0 if quantity is invalid or missing

                try:
                    price = float(price_raw)
                except (ValueError, TypeError):
                    price = 0.0 # Default to 0.0 if price is invalid or missing

                # Logic Step 2b.iv.3: Hitung `subtotal_produk`
                subtotal_produk = qty * price
                
                # Logic Step 2b.iv.4: Tambahkan `subtotal_produk` ke `total_harga_keseluruhan`.
                total_harga_keseluruhan += subtotal_produk
                
                # Logic Step 2b.iv.5: Tambahkan `Kuantitas` ke `jumlah_total_item_di_keranjang`.
                jumlah_total_item_di_keranjang += qty
                
                # Logic Step 2b.iv.6: Tambahkan objek ke `produk_keranjang_untuk_tabel`.
                produk_keranjang_untuk_tabel_data.append({
                    'nama_produk': product_name,
                    'kuantitas': qty,
                    'harga_per_unit_raw': price, # Store raw price for structured data output
                    'harga_per_unit_formatted': f"Rp {price:,.0f}".replace(",", "#").replace(".", ",").replace("#", ".") # Format for table display (Indonesian Rupiah style)
                })
            except Exception as item_parse_error:
                # Log a warning for any malformed item that causes parsing errors, and continue processing.
                print(f"Peringatan: Gagal memparsing item keranjang: {item}. Error: {item_parse_error}")
                continue # Skip this malformed item and proceed with others

        # Logic Step 2b.v: Format `produk_keranjang_untuk_tabel` menjadi representasi tabel yang rapi.
        table_headers = ['Nama Produk', 'Kuantitas', 'Harga per Unit']
        table_rows_for_output = []
        for item_data in produk_keranjang_untuk_tabel_data:
            table_rows_for_output.append([
                item_data['nama_produk'],
                item_data['kuantitas'],
                item_data['harga_per_unit_formatted']
            ])

        # Format total_harga_keseluruhan for display in the output message
        total_harga_formatted_display = f"Rp {total_harga_keseluruhan:,.0f}".replace(",", "#").replace(".", ",").replace("#", ".")

        # Logic Step 2b.vi: Siapkan pesan output
        output_message_plain = "Berikut adalah isi keranjang Anda:"
        # The table itself will be rendered by the UI using result["table"]
        output_message_plain += f"\nTotal Harga: {total_harga_formatted_display}"

        result["status"] = "SUCCESS"
        result["message"] = output_message_plain
        result["output"] = output_message_plain
        result["table"] = {
            "headers": table_headers,
            "rows": table_rows_for_output
        }
        
        # Populate result["data"] as per Output contract
        product_list_for_data = [
            {
                "nama_produk": item_data['nama_produk'],
                "kuantitas": item_data['kuantitas'],
                "harga_per_unit": item_data['harga_per_unit_raw'] # Use raw numeric price for structured data
            } for item_data in produk_keranjang_untuk_tabel_data
        ]

        result["data"].update({
            "total_harga_keseluruhan": total_harga_keseluruhan,
            "jumlah_total_item_di_keranjang": jumlah_total_item_di_keranjang,
            "daftar_produk": product_list_for_data
        })

    except Exception as e:
        # Catch any unexpected system errors during the process
        result["status"] = "ERROR"
        result["message"] = f"Terjadi kesalahan sistem yang tidak terduga saat melihat keranjang belanja: {str(e)}"
    
    return result