import { KintsugiClient } from '@kintsugi-tax/sdk';
import { ShopifyAPI } from '@shopify/shopify-api';

class TaxCalculator {
  private kintsugi: KintsugiClient;
  
  constructor(apiKey: string, orgId: string) {
    this.kintsugi = new KintsugiClient({ apiKey, organizationId: orgId });
  }
  
  async calculateCartTax(cartItems: CartItem[], shippingAddress: Address) {
    // Convert Shopify cart to Kintsugi format
    const lineItems = cartItems.map(item => ({
      quantity: item.quantity,
      price: parseFloat(item.price),
      productTaxCode: item.productTaxCode || 'A_GEN_TAX'
    }));
    
    // Calculate tax
    const taxResult = await this.kintsugi.tax.estimate({
      lineItems,
      shipTo: {
        street1: shippingAddress.address1,
        city: shippingAddress.city,
        state: shippingAddress.provinceCode,
        postalCode: shippingAddress.zip,
        country: shippingAddress.countryCode
      }
    });
    
    return {
      totalTax: taxResult.totalTax,
      taxBreakdown: taxResult.taxBreakdown
    };
  }
}

const express = require('express');
const { KintsugiClient } = require('@kintsugi/sdk');
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

const app = express();
const kintsugi = new KintsugiClient({
  apiKey: process.env.KINTSUGI_API_KEY,
  organizationId: process.env.KINTSUGI_ORG_ID
});

app.post('/webhook/stripe', express.raw({type: 'application/json'}), (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;
  
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);
  } catch (err) {
    return res.status(400).send(`Webhook signature verification failed.`);
  }
  
  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object;
    
    // Calculate tax
    kintsugi.tax.estimate({
      lineItems: [{
        quantity: 1,
        price: paymentIntent.amount / 100,
        productTaxCode: 'A_GEN_TAX'
      }],
      shipTo: {
        street1: paymentIntent.shipping.address.line1,
        city: paymentIntent.shipping.address.city,
        state: paymentIntent.shipping.address.state,
        postalCode: paymentIntent.shipping.address.postal_code,
        country: paymentIntent.shipping.address.country
      }
    }).then(taxResult => {
      // Store tax information
      storeTaxRecord(paymentIntent.id, taxResult);
    });
  }
  
  res.json({received: true});
});

import { KintsugiClient, KintsugiError } from '@kintsugi/sdk';

async function calculateTaxSafely(client: KintsugiClient, transactionData: any) {
  try {
    const result = await client.tax.estimate(transactionData);
    return result;
  } catch (error) {
    if (error instanceof KintsugiError) {
      if (error.statusCode === 429) { // Rate limited
        console.warn('Rate limited, retrying in 60 seconds');
        await new Promise(resolve => setTimeout(resolve, 60000));
        return client.tax.estimate(transactionData);
      } else if (error.statusCode === 400) { // Bad request
        console.error(`Invalid request: ${error.message}`);
        throw new Error(`Invalid transaction data: ${error.message}`);
      } else {
        console.error(`Tax calculation failed: ${error.message}`);
        throw error;
      }
    } else {
      console.error(`Unexpected error: ${error}`);
      throw error;
    }
  }
}

const { KintsugiClient } = require('@kintsugi/sdk');

// Mock the SDK
jest.mock('@kintsugi/sdk', () => ({
  KintsugiClient: jest.fn().mockImplementation(() => ({
    tax: {
      estimate: jest.fn()
    }
  }))
}));

describe('Tax Calculation', () => {
  let client;
  
  beforeEach(() => {
    client = new KintsugiClient({ apiKey: 'test', organizationId: 'test' });
  });
  
  it('should calculate tax correctly', async () => {
    // Mock the response
    client.tax.estimate.mockResolvedValue({
      totalTax: 8.25,
      taxBreakdown: [{ jurisdiction: 'CA', tax: 8.25 }]
    });
    
    // Test the calculation
    const result = await client.tax.estimate({
      lineItems: [{ quantity: 1, price: 100 }],
      shipTo: { state: 'CA', country: 'US' }
    });
    
    expect(result.totalTax).toBe(8.25);
    expect(client.tax.estimate).toHaveBeenCalledTimes(1);
  });
});

import { KintsugiClient } from '@kintsugi-tax/sdk';
import Redis from 'ioredis';

class CachedTaxCalculator {
  private kintsugi: KintsugiClient;
  private redis: Redis;
  private cache = new Map<string, number>();
  
  constructor(apiKey: string, orgId: string) {
    this.kintsugi = new KintsugiClient({ apiKey, organizationId: orgId });
    this.redis = new Redis(process.env.REDIS_URL);
  }
  
  async getTaxRate(state: string, country: string): Promise<number> {
    const cacheKey = `tax_rate:${state}:${country}`;
    
    // Check memory cache first
    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey)!;
    }
    
    // Check Redis cache
    const cachedRate = await this.redis.get(cacheKey);
    if (cachedRate) {
      const rate = parseFloat(cachedRate);
      this.cache.set(cacheKey, rate);
      return rate;
    }
    
    // Calculate and cache
    const result = await this.kintsugi.tax.estimate({
      lineItems: [{ quantity: 1, price: 100 }],
      shipTo: { state, country }
    });
    
    const rate = result.totalTax / 100;
    this.cache.set(cacheKey, rate);
    await this.redis.setex(cacheKey, 3600, rate); // Cache for 1 hour
    
    return rate;
  }
}