import { useState, useCallback, useEffect } from 'react';
import { GetQuantitySamplesUseCase } from '../../domain/usecases/GetQuantitySamplesUseCase';
import { RequestAuthorizationUseCase } from '../../domain/usecases/RequestAuthorizationUseCase';
import { HealthKitRepository } from '../../domain/repositories/HealthKitRepository';
import { HealthKitQuantitySample } from '../../domain/entities/HealthKitSample';

export interface UseHealthKitConfig {
  repository: HealthKitRepository;
}

export function useHealthKit(config: UseHealthKitConfig) {
  const [isAvailable, setIsAvailable] = useState<boolean>(false);
  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);
  const [loading, setLoading] = useState<boolean>(false);
  const [error, setError] = useState<string | null>(null);

  const getQuantitySamplesUseCase = new GetQuantitySamplesUseCase(config.repository);
  const requestAuthorizationUseCase = new RequestAuthorizationUseCase(config.repository);

  useEffect(() => {
    setIsAvailable(config.repository.isAvailable());
  }, [config.repository]);

  const requestAuthorization = useCallback(async (identifiers?: string[]): Promise<boolean> => {
    try {
      setLoading(true);
      setError(null);

      let authorized: boolean;
      
      if (identifiers && identifiers.length > 0) {
        authorized = await requestAuthorizationUseCase.executeSelective(identifiers);
      } else {
        authorized = await requestAuthorizationUseCase.execute();
      }

      setIsAuthorized(authorized);
      return authorized;
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
      setError(errorMessage);
      return false;
    } finally {
      setLoading(false);
    }
  }, [requestAuthorizationUseCase]);

  const getQuantitySamplesForDays = useCallback(async (
    identifier: string,
    unit: string,
    days: number
  ): Promise<HealthKitQuantitySample[]> => {
    try {
      setError(null);
      return await getQuantitySamplesUseCase.executeForDays(identifier, unit, days);
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
      setError(errorMessage);
      throw err;
    }
  }, [getQuantitySamplesUseCase]);

  const getQuantitySamplesForRange = useCallback(async (
    identifier: string,
    unit: string,
    startDate: Date,
    endDate: Date
  ): Promise<HealthKitQuantitySample[]> => {
    try {
      setError(null);
      return await getQuantitySamplesUseCase.execute(identifier, unit, { startDate, endDate });
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
      setError(errorMessage);
      throw err;
    }
  }, [getQuantitySamplesUseCase]);

  const clearError = useCallback(() => {
    setError(null);
  }, []);

  return {
    // State
    isAvailable,
    isAuthorized,
    loading,
    error,
    
    // Actions
    requestAuthorization,
    getQuantitySamplesForDays,
    getQuantitySamplesForRange,
    clearError
  };
}