// Go Gin后端埋点示例
package main

import (
    "time"
    "github.com/gin-gonic/gin"
)

func productDetail(c *gin.Context) {
    productID := c.Query("id")
    
    // 手动埋点代码
    analytics.Track(analytics.Track{
        UserId: getUserID(c),
        Event:  "view_product",
        Properties: map[string]interface{}{
            "product_id":    productID,
            "product_name":  getProductName(productID),
            "product_price": getProductPrice(productID),
            "source":        c.DefaultQuery("from", "direct"),
            "timestamp":     time.Now().Unix(),
        },
    })
    
    c.HTML(200, "product_detail.html", gin.H{})
}

func addToCart(c *gin.Context) {
    var data map[string]interface{}
    c.BindJSON(&data)
    
    // 加购埋点
    analytics.Track(analytics.Track{
        UserId: c.GetString("user_id"),
        Event:  "add_to_cart",
        Properties: map[string]interface{}{
            "product_id": data["product_id"],
            "quantity":   data["quantity"],
            "price":      data["price"],
        },
    })
    
    c.JSON(200, gin.H{"success": true})
}

{
  "event": "button_click_add_cart",
  "properties": {
    // ========== 公共属性 ==========
    "user_id": "123456",
    "device_id": "abc-def-ghi",
    "timestamp": 1698220845000,
    
    // ========== 商品属性 ==========
    "product_id": "100001",
    "product_name": "iPhone 15 Pro",
    "product_price": 7999,
    "product_sku_id": "sku_001",
    
    // ========== 操作属性 ==========
    "quantity": 1,
    "selected_color": "钛金色",
    "selected_storage": "256GB",
    "is_first_add": true,
    
    // ========== 行为属性 ==========
    "time_on_page": 45.3,
    "images_viewed": 5,
    "detail_expanded": true,
    "reviews_viewed": true,
    
    // ========== 结果属性 ==========
    "cart_item_count": 3,
    "cart_total_amount": 15998,
    "operation_result": "success"
  }
}

// ========== Vue 3框架埋点实现 ==========

// 1. 埋点插件 (analytics-plugin.js)
export default {
    install(app, options) {
        // 初始化SDK
        AnalyticsSDK.initialize(options.appKey, {
            endpoint: options.endpoint,
            debug: options.debug || false
        });
        
        // 全局混入 - 自动追踪组件加载
        app.mixin({
            mounted() {
                if (this.$options.analyticsName) {
                    AnalyticsSDK.track('component_mounted', {
                        component_name: this.$options.analyticsName,
                        route_path: this.$route?.path
                    });
                }
            }
        });
        
        // 挂载到全局属性
        app.config.globalProperties.$analytics = {
            // 追踪事件
            track: (event, properties) => {
                AnalyticsSDK.track(event, properties);
            },
            // 设置用户ID
            setUserID: (userID) => {
                AnalyticsSDK.setUserID(userID);
            },
            // 追踪页面浏览
            trackPageView: (properties) => {
                AnalyticsSDK.trackPageView(properties);
            }
        };
        
        // 路由埋点
        if (options.router) {
            options.router.afterEach((to, from) => {
                AnalyticsSDK.trackPageView({
                    page_path: to.path,
                    page_name: to.name,
                    page_params: JSON.stringify(to.params),
                    from_path: from.path,
                    from_name: from.name
                });
            });
        }
    }
};

// 2. main.js - 注册插件
import { createApp } from 'vue';
import App from './App.vue';
import router from './router';
import analyticsPlugin from './plugins/analytics-plugin';

const app = createApp(App);

app.use(router);
app.use(analyticsPlugin, {
    appKey: 'your-app-key',
    endpoint: 'https://analytics.example.com/track',
    router: router,
    debug: process.env.NODE_ENV === 'development'
});

app.mount('#app');

// 3. ProductDetail.vue - 商品详情页组件
<template>
  <div class="product-detail">
    <h1>{{ product.name }}</h1>
    <div class="product-images">
      <img 
        v-for="(img, index) in product.images" 
        :key="index"
        :src="img" 
        @click="handleImageClick(index, img)"
        class="product-image"
      />
    </div>
    
    <div class="product-info">
      <p class="price">¥{{ product.price }}</p>
      <button @click="handleAddToCart" class="add-to-cart-btn">
        加入购物车
      </button>
    </div>
    
    <div class="reviews">
      <button @click="toggleReviews">
        {{ showReviews ? '收起' : '展开' }}评论
      </button>
      <div v-if="showReviews" class="reviews-content">
        <!-- 评论内容 -->
      </div>
    </div>
  </div>
</template>

<script>
export default {
    name: 'ProductDetail',
    analyticsName: 'ProductDetail', // 用于自动埋点
    
    data() {
        return {
            product: {
                id: '100001',
                name: 'iPhone 15 Pro',
                price: 7999,
                images: [
                    '/images/product1.jpg',
                    '/images/product2.jpg',
                    '/images/product3.jpg'
                ]
            },
            showReviews: false,
            pageEnterTime: null
        };
    },
    
    mounted() {
        // 记录进入时间
        this.pageEnterTime = Date.now();
        
        // 页面浏览埋点
        this.$analytics.track('page_view_product_detail', {
            product_id: this.product.id,
            product_name: this.product.name,
            product_price: this.product.price,
            source: this.$route.query.from || 'direct'
        });
    },
    
    beforeUnmount() {
        // 页面离开埋点 - 记录停留时长
        const timeOnPage = (Date.now() - this.pageEnterTime) / 1000;
        this.$analytics.track('page_leave_product_detail', {
            product_id: this.product.id,
            time_on_page: timeOnPage
        });
    },
    
    methods: {
        handleAddToCart() {
            // 加购埋点
            this.$analytics.track('button_click_add_cart', {
                product_id: this.product.id,
                product_name: this.product.name,
                product_price: this.product.price,
                quantity: 1,
                time_on_page: (Date.now() - this.pageEnterTime) / 1000
            });
            
            // 执行加购逻辑
            this.addToCart();
        },
        
        handleImageClick(index, imageUrl) {
            // 图片点击埋点
            this.$analytics.track('image_click_product', {
                product_id: this.product.id,
                image_index: index,
                image_url: imageUrl
            });
        },
        
        toggleReviews() {
            this.showReviews = !this.showReviews;
            
            // 评论展开/收起埋点
            this.$analytics.track(
                this.showReviews ? 'button_click_expand_reviews' : 'button_click_collapse_reviews',
                {
                    product_id: this.product.id
                }
            );
        },
        
        addToCart() {
            // 实际的加购业务逻辑
            console.log('Adding to cart...');
        }
    }
};
</script>

// ========== Go Gin 后端埋点实现 ==========

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "time"
    
    "github.com/gin-gonic/gin"
)

// AnalyticsSDK 埋点SDK结构体
type AnalyticsSDK struct {
    Endpoint string
    AppKey   string
    Client   *http.Client
}

// EventData 事件数据结构
type EventData struct {
    AppKey     string                 `json:"app_key"`
    UserID     string                 `json:"user_id"`
    Event      string                 `json:"event"`
    Properties map[string]interface{} `json:"properties"`
    Timestamp  int64                  `json:"timestamp"`
    ServerTime string                 `json:"server_time"`
    ServerIP   string                 `json:"server_ip"`
}

// NewAnalyticsSDK 创建SDK实例
func NewAnalyticsSDK(endpoint, appKey string) *AnalyticsSDK {
    return &AnalyticsSDK{
        Endpoint: endpoint,
        AppKey:   appKey,
        Client: &http.Client{
            Timeout: 2 * time.Second,
        },
    }
}

// Track 追踪事件
func (sdk *AnalyticsSDK) Track(userID, event string, properties map[string]interface{}) {
    eventData := EventData{
        AppKey:     sdk.AppKey,
        UserID:     userID,
        Event:      event,
        Properties: properties,
        Timestamp:  time.Now().UnixMilli(),
        ServerTime: time.Now().Format(time.RFC3339),
    }
    
    // 异步发送（生产环境建议使用消息队列）
    go func() {
        data, err := json.Marshal(eventData)
        if err != nil {
            // 记录错误日志
            return
        }
        
        resp, err := sdk.Client.Post(
            sdk.Endpoint,
            "application/json",
            bytes.NewBuffer(data),
        )
        if err != nil {
            // 记录错误日志
            return
        }
        defer resp.Body.Close()
        
        if resp.StatusCode != 200 {
            // 记录警告日志
        }
    }()
}

// TrackMiddleware 埋点中间件
func (sdk *AnalyticsSDK) TrackMiddleware(eventName string) gin.HandlerFunc {
    return func(c *gin.Context) {
        startTime := time.Now()
        
        // 执行业务逻辑
        c.Next()
        
        // 记录接口调用埋点
        duration := time.Since(startTime).Milliseconds()
        
        if userID, exists := c.Get("user_id"); exists {
            properties := map[string]interface{}{
                "path":     c.Request.URL.Path,
                "method":   c.Request.Method,
                "status":   c.Writer.Status(),
                "duration": duration,
                "success":  c.Writer.Status() < 400,
            }
            sdk.Track(userID.(string), eventName, properties)
        }
    }
}

// 全局SDK实例
var analytics *AnalyticsSDK

func main() {
    // 初始化SDK
    analytics = NewAnalyticsSDK(
        "http://analytics-api.example.com/track",
        "your-app-key",
    )
    
    r := gin.Default()
    
    // 用户认证中间件
    r.Use(AuthMiddleware())
    
    // ========== API路由 ==========
    
    // 商品详情API
    r.GET("/api/product/:id", analytics.TrackMiddleware("api_product_view"), getProduct)
    
    // 加入购物车API
    r.POST("/api/cart/add", addToCart)
    
    // 创建订单API
    r.POST("/api/order/create", createOrder)
    
    // 支付回调API
    r.POST("/api/payment/callback", paymentCallback)
    
    r.Run(":8080")
}

// ========== 中间件 ==========

// AuthMiddleware 认证中间件
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token != "" {
            userID := verifyToken(token)
            c.Set("user_id", userID)
        }
        c.Next()
    }
}

// ========== API处理函数 ==========

// getProduct 商品详情
func getProduct(c *gin.Context) {
    productID := c.Param("id")
    product := getProductFromDB(productID)
    
    // 业务埋点
    if userID, exists := c.Get("user_id"); exists {
        source := c.DefaultQuery("from", "direct")
        
        analytics.Track(userID.(string), "product_view", map[string]interface{}{
            "product_id":    productID,
            "product_name":  product["name"],
            "product_price": product["price"],
            "product_stock": product["stock"],
            "category":      product["category"],
            "view_source":   source,
        })
    }
    
    c.JSON(http.StatusOK, product)
}

// addToCart 加入购物车
func addToCart(c *gin.Context) {
    var req struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
    }
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    userID, _ := c.Get("user_id")
    
    // 执行加购逻辑
    success := addToCartService(userID.(string), req.ProductID, req.Quantity)
    
    if success {
        // 加购成功埋点
        product := getProductFromDB(req.ProductID)
        cartInfo := getCartInfo(userID.(string))
        
        analytics.Track(userID.(string), "add_to_cart_success", map[string]interface{}{
            "product_id":       req.ProductID,
            "product_name":     product["name"],
            "product_price":    product["price"],
            "quantity":         req.Quantity,
            "cart_total_items": cartInfo["total_items"],
            "cart_total_amount": cartInfo["total_amount"],
        })
        
        c.JSON(http.StatusOK, gin.H{
            "success": true,
            "cart":    cartInfo,
        })
    } else {
        // 加购失败埋点
        analytics.Track(userID.(string), "add_to_cart_failed", map[string]interface{}{
            "product_id":   req.ProductID,
            "quantity":     req.Quantity,
            "error_reason": "out_of_stock",
        })
        
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error":   "Out of stock",
        })
    }
}

// createOrder 创建订单
func createOrder(c *gin.Context) {
    var req map[string]interface{}
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    userID, _ := c.Get("user_id")
    
    // 创建订单
    order := createOrderService(userID.(string), req)
    
    // 订单创建埋点
    analytics.Track(userID.(string), "order_created", map[string]interface{}{
        "order_id":          order["id"],
        "order_amount":      order["amount"],
        "discount_amount":   order["discount"],
        "actual_amount":     order["actual_amount"],
        "product_count":     len(order["items"].([]interface{})),
        "payment_method":    req["payment_method"],
        "shipping_address_id": req["address_id"],
        "coupon_id":         req["coupon_id"],
        "is_first_order":    isFirstOrder(userID.(string)),
    })
    
    c.JSON(http.StatusOK, order)
}

// paymentCallback 支付回调
func paymentCallback(c *gin.Context) {
    var data map[string]interface{}
    if err := c.ShouldBindJSON(&data); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    orderID := data["order_id"].(string)
    
    // 验证支付结果
    if verifyPayment(data) {
        // 更新订单状态
        updateOrderStatus(orderID, "paid")
        
        // 支付成功埋点
        order := getOrder(orderID)
        analytics.Track(order["user_id"].(string), "payment_success", map[string]interface{}{
            "order_id":       orderID,
            "order_amount":   order["amount"],
            "payment_method": data["payment_method"],
            "payment_channel": data["channel"],
            "payment_time":   time.Now().Format(time.RFC3339),
        })
        
        c.JSON(http.StatusOK, gin.H{"success": true})
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"success": false})
    }
}

// ========== 辅助函数 ==========

func verifyToken(token string) string {
    // 实际的token验证逻辑
    return "user_123"
}

func getProductFromDB(productID string) map[string]interface{} {
    // 实际的数据库查询逻辑
    return map[string]interface{}{
        "id":       productID,
        "name":     "iPhone 15 Pro",
        "price":    7999,
        "stock":    100,
        "category": "Electronics",
    }
}

func addToCartService(userID, productID string, quantity int) bool {
    // 实际的加购逻辑
    return true
}

func getCartInfo(userID string) map[string]interface{} {
    // 实际的购物车查询逻辑
    return map[string]interface{}{
        "total_items":  3,
        "total_amount": 15998,
    }
}

func createOrderService(userID string, data map[string]interface{}) map[string]interface{} {
    // 实际的订单创建逻辑
    return map[string]interface{}{
        "id":            "ORD123456",
        "amount":        7999,
        "discount":      200,
        "actual_amount": 7799,
        "items":         []interface{}{},
    }
}

func isFirstOrder(userID string) bool {
    // 实际的查询逻辑
    return true
}

func verifyPayment(data map[string]interface{}) bool {
    // 实际的支付验证逻辑
    return true
}

func updateOrderStatus(orderID, status string) {
    // 实际的更新逻辑
}

func getOrder(orderID string) map[string]interface{} {
    // 实际的查询逻辑
    return map[string]interface{}{
        "user_id": "user_123",
        "amount":  7999,
    }
}