'use client';

import { useState, useMemo } from 'react';

interface Product {
  id: string;
  name: string;
  price: number;
  category: string;
  rating: number;
}

interface Props {
  products: Product[];
}

export function ProductList({ products }: Props) {
  const [category, setCategory] = useState<string>('all');
  const [sortBy, setSortBy] = useState<string>('name');
  const [page, setPage] = useState(1);
  const pageSize = 12;

  const filteredProducts = useMemo(() => {
    let result = products;
    
    if (category !== 'all') {
      result = result.filter(p => p.category === category);
    }
    
    result = [...result].sort((a, b) => {
      switch (sortBy) {
        case 'price_asc': return a.price - b.price;
        case 'price_desc': return b.price - a.price;
        case 'rating': return b.rating - a.rating;
        default: return a.name.localeCompare(b.name);
      }
    });
    
    return result;
  }, [products, category, sortBy]);

  const paginatedProducts = useMemo(() => {
    const start = (page - 1) * pageSize;
    return filteredProducts.slice(start, start + pageSize);
  }, [filteredProducts, page]);

  const totalPages = Math.ceil(filteredProducts.length / pageSize);

  return (
    <div className="space-y-4">
      <div className="flex gap-4">
        <select value={category} onChange={e => setCategory(e.target.value)}>
          <option value="all">All Categories</option>
          <option value="electronics">Electronics</option>
          <option value="clothing">Clothing</option>
        </select>
        
        <select value={sortBy} onChange={e => setSortBy(e.target.value)}>
          <option value="name">Sort by Name</option>
          <option value="price_asc">Price: Low to High</option>
          <option value="price_desc">Price: High to Low</option>
          <option value="rating">Highest Rated</option>
        </select>
      </div>

      <div className="grid grid-cols-3 gap-4">
        {paginatedProducts.map(product => (
          <ProductCard key={product.id} product={product} />
        ))}
      </div>

      <div className="flex justify-center gap-2">
        {Array.from({ length: totalPages }, (_, i) => (
          <button
            key={i}
            onClick={() => setPage(i + 1)}
            className={page === i + 1 ? 'font-bold' : ''}
          >
            {i + 1}
          </button>
        ))}
      </div>
    </div>
  );
}

import pandas as pd
from pathlib import Path
from dataclasses import dataclass
from typing import Optional

@dataclass
class DataQualityReport:
    total_rows: int
    missing_values: dict[str, int]
    duplicates: int
    outliers: dict[str, int]

class DataPipeline:
    def __init__(self, input_path: Path, output_path: Path):
        self.input_path = input_path
        self.output_path = output_path
        self.df: Optional[pd.DataFrame] = None
    
    def load(self) -> 'DataPipeline':
        """Load data from CSV."""
        self.df = pd.read_csv(self.input_path)
        return self
    
    def clean(self) -> 'DataPipeline':
        """Clean the data."""
        if self.df is None:
            raise ValueError("Data not loaded. Call load() first.")
        
        # Remove duplicates
        self.df = self.df.drop_duplicates()
        
        # Handle missing values
        numeric_cols = self.df.select_dtypes(include=['number']).columns
        self.df[numeric_cols] = self.df[numeric_cols].fillna(
            self.df[numeric_cols].median()
        )
        
        categorical_cols = self.df.select_dtypes(include=['object']).columns
        self.df[categorical_cols] = self.df[categorical_cols].fillna('Unknown')
        
        return self
    
    def validate(self) -> DataQualityReport:
        """Validate data quality."""
        if self.df is None:
            raise ValueError("Data not loaded.")
        
        return DataQualityReport(
            total_rows=len(self.df),
            missing_values=self.df.isnull().sum().to_dict(),
            duplicates=self.df.duplicated().sum(),
            outliers=self._detect_outliers()
        )
    
    def _detect_outliers(self) -> dict[str, int]:
        """Detect outliers using IQR method."""
        outliers = {}
        numeric_cols = self.df.select_dtypes(include=['number']).columns
        
        for col in numeric_cols:
            Q1 = self.df[col].quantile(0.25)
            Q3 = self.df[col].quantile(0.75)
            IQR = Q3 - Q1
            lower = Q1 - 1.5 * IQR
            upper = Q3 + 1.5 * IQR
            outliers[col] = ((self.df[col] < lower) | (self.df[col] > upper)).sum()
        
        return outliers
    
    def save(self) -> Path:
        """Save processed data."""
        if self.df is None:
            raise ValueError("Data not loaded.")
        
        self.output_path.parent.mkdir(parents=True, exist_ok=True)
        self.df.to_csv(self.output_path, index=False)
        return self.output_path

# Usage
pipeline = DataPipeline(
    input_path=Path('data/raw.csv'),
    output_path=Path('data/processed.csv')
)

report = pipeline.load().clean().validate()
pipeline.save()

print(f"Processed {report.total_rows} rows")
print(f"Duplicates: {report.duplicates}")
print(f"Outliers: {report.outliers}")

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    pb "user-service/proto"
)

type UserServiceServer struct {
    pb.UnimplementedUserServiceServer
    users map[string]*pb.User
}

func NewUserServiceServer() *UserServiceServer {
    return &UserServiceServer{
        users: make(map[string]*pb.User),
    }
}

func (s *UserServiceServer) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.User, error) {
    if req.Name == "" {
        return nil, status.Error(codes.InvalidArgument, "name is required")
    }
    
    if req.Email == "" {
        return nil, status.Error(codes.InvalidArgument, "email is required")
    }
    
    user := &pb.User{
        Id:    generateID(),
        Name:  req.Name,
        Email: req.Email,
    }
    
    s.users[user.Id] = user
    log.Printf("Created user: %s", user.Id)
    
    return user, nil
}

func (s *UserServiceServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    user, ok := s.users[req.Id]
    if !ok {
        return nil, status.Error(codes.NotFound, "user not found")
    }
    return user, nil
}

func (s *UserServiceServer) ListUsers(ctx context.Context, req *pb.ListUsersRequest) (*pb.ListUsersResponse, error) {
    users := make([]*pb.User, 0, len(s.users))
    for _, user := range s.users {
        users = append(users, user)
    }
    
    // Pagination
    start := int(req.Page * req.PageSize)
    if start >= len(users) {
        return &pb.ListUsersResponse{Users: []*pb.User{}}, nil
    }
    
    end := start + int(req.PageSize)
    if end > len(users) {
        end = len(users)
    }
    
    return &pb.ListUsersResponse{
        Users:     users[start:end],
        TotalCount: int32(len(users)),
    }, nil
}

func (s *UserServiceServer) DeleteUser(ctx context.Context, req *pb.DeleteUserRequest) (*pb.DeleteUserResponse, error) {
    if _, ok := s.users[req.Id]; !ok {
        return nil, status.Error(codes.NotFound, "user not found")
    }
    
    delete(s.users, req.Id)
    log.Printf("Deleted user: %s", req.Id)
    
    return &pb.DeleteUserResponse{Success: true}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, NewUserServiceServer())
    
    log.Printf("Server listening on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

func generateID() string {
    return fmt.Sprintf("user_%d", time.Now().UnixNano())
}