Function bodies 81 total

export async function getContract(id: string): Promise<ActiveContract | null> {
  const { data, error } = await supabase
    .from('active_contracts')
    .select('*, template:contract_templates(*), party_a:profiles!party_a_id(*), party_b:profiles!party_b_id(*)')
    .eq('id', id)
    .single();

  if (error) throw error;
  return data;
}

export async function createContract(params: {
  template_id: string;
  party_a_id: string;
  user_inputs: Record<string, any>;
  party_b_phone?: string;
  party_b_email?: string;
  payment_amount?: number;
}): Promise<ActiveContract> {
  const { data, error } = await supabase
    .from('active_contracts')
    .insert({
      ...params,
      status: 'pending_acceptance' as ContractStatus,
    })
    .select()
    .single();

  if (error) throw error;

  await logContractEvent(data.id, params.party_a_id, 'contract_created', {});
  return data;
}

export async function updateContractStatus(
  contractId: string,
  status: ContractStatus,
  actorId: string,
  updates?: Partial<ActiveContract>
): Promise<ActiveContract> {
  const { data, error } = await supabase
    .from('active_contracts')
    .update({ status, ...updates, updated_at: new Date().toISOString() })
    .eq('id', contractId)
    .select()
    .single();

  if (error) throw error;

  await logContractEvent(contractId, actorId, `status_changed_to_${status}`, { status });
  return data;
}

export async function acceptContract(
  contractId: string,
  partyBId: string,
  partyBInputs: Record<string, any>
): Promise<ActiveContract> {
  const { data: existing } = await supabase
    .from('active_contracts')
    .select('user_inputs')
    .eq('id', contractId)
    .single();

  const mergedInputs = { ...(existing?.user_inputs || {}), ...partyBInputs };

  const { data, error } = await supabase
    .from('active_contracts')
    .update({
      party_b_id: partyBId,
      user_inputs: mergedInputs,
      status: 'pending_payment' as ContractStatus,
      updated_at: new Date().toISOString(),
    })
    .eq('id', contractId)
    .select()
    .single();

  if (error) throw error;

  await logContractEvent(contractId, partyBId, 'contract_accepted', {});
  return data;
}

export async function logContractEvent(
  contractId: string,
  actorId: string,
  eventType: string,
  metadata: Record<string, any>
): Promise<void> {
  await supabase.from('contract_events').insert({
    contract_id: contractId,
    actor_id: actorId,
    event_type: eventType,
    metadata,
  });
}

export async function getContractEvents(contractId: string) {
  const { data, error } = await supabase
    .from('contract_events')
    .select('*, actor:profiles(*)')
    .eq('contract_id', contractId)
    .order('created_at', { ascending: true });

  if (error) throw error;
  return data || [];
}

export async function getNotifications(userId: string): Promise<Notification[]> {
  const { data, error } = await supabase
    .from('notifications')
    .select('*')
    .eq('user_id', userId)
    .order('created_at', { ascending: false });

  if (error) throw error;
  return data || [];
}

export async function markAsRead(notificationId: string): Promise<void> {
  await supabase
    .from('notifications')
    .update({ is_read: true })
    .eq('id', notificationId);
}

export async function markAllAsRead(userId: string): Promise<void> {
  await supabase
    .from('notifications')
    .update({ is_read: true })
    .eq('user_id', userId)
    .eq('is_read', false);
}

export async function getUnreadCount(userId: string): Promise<number> {
  const { count, error } = await supabase
    .from('notifications')
    .select('*', { count: 'exact', head: true })
    .eq('user_id', userId)
    .eq('is_read', false);

  if (error) throw error;
  return count || 0;
}

export async function getProfile(userId: string): Promise<Profile | null> {
  const { data, error } = await supabase
    .from('profiles')
    .select('*')
    .eq('id', userId)
    .single();

  if (error) throw error;
  return data;
}

export async function updateProfile(
  userId: string,
  updates: Partial<Pick<Profile, 'full_name' | 'phone' | 'register_number' | 'avatar_url' | 'preferred_locale'>>
): Promise<Profile> {
  const { data, error } = await supabase
    .from('profiles')
    .update({ ...updates, updated_at: new Date().toISOString() })
    .eq('id', userId)
    .select()
    .single();

  if (error) throw error;
  return data;
}

export async function getTemplates(): Promise<ContractTemplate[]> {
  const { data, error } = await supabase
    .from('contract_templates')
    .select('*')
    .eq('is_active', true)
    .order('created_at', { ascending: true });

  if (error) throw error;
  return data || [];
}

export async function getTemplateBySlug(slug: string): Promise<ContractTemplate | null> {
  const { data, error } = await supabase
    .from('contract_templates')
    .select('*')
    .eq('slug', slug)
    .eq('is_active', true)
    .single();

  if (error) throw error;
  return data;
}

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [session, setSession] = useState<Session | null>(null);
  const [profile, setProfile] = useState<Profile | null>(null);
  const [loading, setLoading] = useState(true);

  const fetchProfile = useCallback(async (userId: string) => {
    const { data } = await supabase
      .from('profiles')
      .select('*')
      .eq('id', userId)
      .single();
    setProfile(data);
  }, []);

  useEffect(() => {
    supabase.auth.getSession().then(({ data: { session } }) => {
      setSession(session);
      if (session?.user) fetchProfile(session.user.id);
      setLoading(false);
    });

    const { data: { subscription } } = supabase.auth.onAuthStateChange((_event, session) => {
      setSession(session);
      if (session?.user) {
        fetchProfile(session.user.id);
      } else {
        setProfile(null);
      }
    });

    return () => subscription.unsubscribe();
  }, [fetchProfile]);

  const signInWi

export function useAuth() {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
}

export function I18nProvider({ children, initialLocale = 'mn' }: { children: React.ReactNode; initialLocale?: Locale }) {
  const [locale, setLocale] = useState<Locale>(initialLocale);

  const t = useCallback(
    (key: string, params?: Record<string, string | number>) => {
      let text = translations[locale]?.[key] || translations['mn']?.[key] || key;
      if (params) {
        Object.entries(params).forEach(([k, v]) => {
          text = text.replace(`{{${k}}}`, String(v));
        });
      }
      return text;
    },
    [locale]
  );

  return (
    <I18nContext.Provider value={{ locale, setLocale, t }}>
      {children}
    </I18nContext.Provider>
  );
}

export function useTranslation() {
  return useContext(I18nContext);
}

async function generateSignatureHash(data: string): Promise<string> {
  const encoder = new TextEncoder();
  const dataBuffer = encoder.encode(data);
  const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

export function canTransition(from: ContractStatus, to: ContractStatus): boolean {
  return VALID_TRANSITIONS[from]?.includes(to) ?? false;
}

export function getStatusColor(status: ContractStatus): string {
  switch (status) {
    case 'draft': return '#94A3B8';
    case 'pending_acceptance':
    case 'pending_payment':
    case 'pending_signature': return '#D97706';
    case 'paid':
    case 'signed': return '#2563EB';
    case 'completed': return '#16A34A';
    case 'cancelled':
    case 'expired': return '#DC2626';
    default: return '#94A3B8';
  }
}

export function isActiveStatus(status: ContractStatus): boolean {
  return !['completed', 'cancelled', 'expired'].includes(status);
}

export function createContractAcceptLink(contractId: string): string {
  return Linking.createURL(`/contract/accept/${contractId}`);
}

export function createContractSignLink(contractId: string): string {
  return Linking.createURL(`/contract/sign/${contractId}`);
}

export function formatCurrency(amount: number): string {
  return new Intl.NumberFormat('mn-MN', {
    style: 'decimal',
    minimumFractionDigits: 0,
    maximumFractionDigits: 0,
  }).format(amount) + '₮';
}

export function formatDate(dateString: string, locale: 'mn' | 'en' = 'mn'): string {
  const date = new Date(dateString);
  return date.toLocaleDateString(locale === 'mn' ? 'mn-MN' : 'en-US', {
    year: 'numeric',
    month: 'long',
    day: 'numeric',
  });
}

export function formatDateTime(dateString: string, locale: 'mn' | 'en' = 'mn'): string {
  const date = new Date(dateString);
  return date.toLocaleDateString(locale === 'mn' ? 'mn-MN' : 'en-US', {
    year: 'numeric',
    month: 'short',
    day: 'numeric',
    hour: '2-digit',
    minute: '2-digit',
  });
}

export function formatPhone(phone: string): string {
  const cleaned = phone.replace(/\D/g, '');
  if (cleaned.length === 8) {
    return `${cleaned.slice(0, 4)}-${cleaned.slice(4)}`;
  }
  return phone;
}

export function isValidPhone(phone: string): boolean {
  const cleaned = phone.replace(/\D/g, '');
  return /^[89]\d{7}$/.test(cleaned);
}

export function isValidEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

export function isValidRegisterNumber(rn: string): boolean {
  return /^[А-Яа-яЁё]{2}\d{8}$/.test(rn);
}