Kash - Personal Finance App

import { create } from 'zustand';
import { persist, createJSONStorage } from 'zustand/middleware';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { supabase } from '@/lib/supabase';

const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes

interface TransactionsState {
  transactions: TransactionWithCategory[];
  loading: boolean;
  lastFetched: number | null;
}

interface TransactionsActions {
  fetchTransactions: (userId: string, forceRefresh?: boolean) => Promise<void>;
  addTransaction: (userId: string, transaction: Transaction) => Promise<{ error: Error | null }>;
}

export const useTransactionsStore = create<TransactionsState & TransactionsActions>()(
  persist(
    (set, get) => ({
      transactions: [],
      loading: false,
      lastFetched: null,

      fetchTransactions: async (userId: string, forceRefresh = false) => {
        const { lastFetched, transactions } = get();
        const now = Date.now();

        // Use cache if valid and not forcing refresh
        if (!forceRefresh && lastFetched && now - lastFetched < CACHE_DURATION && transactions.length > 0) {
          return;
        }

        set({ loading: true });
        const { data, error } = await supabase
          .from('transactions')
          .select('*, category:categories(*)')
          .eq('user_id', userId)
          .order('transaction_date', { ascending: false });

        if (!error) {
          set({ transactions: data || [], loading: false, lastFetched: Date.now() });
        }
      },

      addTransaction: async (userId, transaction) => {
        const { error } = await supabase.from('transactions').insert({
          ...transaction,
          user_id: userId,
        });

        if (!error) {
          await get().fetchTransactions(userId, true);
        }

        return { error };
      },
    }),
    {
      name: 'kash-transactions',
      storage: createJSONStorage(() => AsyncStorage),
    }
  )
);

import { useColorScheme as useDeviceColorScheme } from 'react-native';
import { useSettingsStore } from '@/stores';
import Colors from '@/constants/Colors';

export function useTheme() {
  const deviceColorScheme = useDeviceColorScheme();
  const { theme } = useSettingsStore();

  const colorScheme = theme === 'system' ? (deviceColorScheme ?? 'light') : theme;

  return {
    colorScheme,
    colors: Colors[colorScheme],
    isDark: colorScheme === 'dark',
  };
}

// Usage in components:
function MyComponent() {
  const { colors, isDark } = useTheme();
  
  return (
    <View style={{ backgroundColor: colors.background }}>
      <Text style={{ color: colors.text }}>Hello</Text>
    </View>
  );
}

import { generateInsights } from '@/lib/ai';
import AsyncStorage from '@react-native-async-storage/async-storage';

const CACHE_KEY = 'kash-ai-insights';
const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours

interface CachedInsights {
  insights: string[];
  timestamp: number;
  transactionCount: number;
}

export function AIInsightsCard() {
  const { transactions } = useTransactionsStore();
  const { budgets } = useBudgetsStore();
  const { language } = useSettingsStore();
  const [insights, setInsights] = useState<string[]>([]);

  // Load cached insights
  useEffect(() => {
    loadCachedInsights();
  }, []);

  const loadCachedInsights = async () => {
    const cached = await AsyncStorage.getItem(CACHE_KEY);
    if (cached) {
      const data: CachedInsights = JSON.parse(cached);
      const now = Date.now();
      if (now - data.timestamp < CACHE_DURATION && 
          Math.abs(data.transactionCount - transactions.length) < 5) {
        setInsights(data.insights);
      }
    }
  };

  const handleGenerateInsights = async () => {
    const result = await generateInsights(transactions, budgets, language);
    if (result.insights.length > 0) {
      setInsights(result.insights);
      await AsyncStorage.setItem(CACHE_KEY, JSON.stringify({
        insights: result.insights,
        timestamp: Date.now(),
        transactionCount: transactions.length,
      }));
    }
  };

  return (
    <View>
      {insights.map((insight, i) => (
        <Text key={i}>{insight}</Text>
      ))}
      <Button onPress={handleGenerateInsights} title="Get Insights" />
    </View>
  );
}

import { documentDirectory, writeAsStringAsync, EncodingType } from 'expo-file-system/legacy';
import { shareAsync } from 'expo-sharing';

export async function exportTransactionsToCSV(
  transactions: TransactionWithCategory[],
  filename?: string
): Promise<{ success: boolean; error?: string }> {
  try {
    // Create CSV content
    const headers = ['Date', 'Type', 'Category', 'Amount', 'Description'];
    const rows = transactions.map((t) => [
      t.transaction_date,
      t.type,
      t.category?.name || '',
      t.amount.toFixed(2),
      `"${(t.description || '').replace(/"/g, '""')}"`,
    ]);

    const csvContent = [headers.join(','), ...rows.map((row) => row.join(','))].join('\n');

    // Write file
    const date = new Date().toISOString().split('T')[0];
    const finalFilename = filename || `kash-transactions-${date}.csv`;
    const filePath = `${documentDirectory}${finalFilename}`;

    await writeAsStringAsync(filePath, csvContent, { encoding: EncodingType.UTF8 });

    // Share file
    await shareAsync(filePath, {
      mimeType: 'text/csv',
      dialogTitle: 'Export Transactions',
    });

    return { success: true };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to export',
    };
  }
}