import AsyncStorage from '@react-native-async-storage/async-storage';
import type { MCGenderEnum } from '../domain/MCGenderEnum';

export class UserService {
  private static USER_ID_KEY = 'user_id';
  private static GAID_KEY = 'gaid';
  private static IDFA_KEY = 'idfa';
  private static GENDER_KEY = 'gender';
  private static AGE_KEY = 'age';
  private static EMAIL_KEY = 'email';
  private static CURRENCY_KEY = 'partner_virtual_currency';
  private static AFF_SUB1_KEY = 'aff_sub1';
  private static AFF_SUB2_KEY = 'aff_sub2';
  private static AFF_SUB3_KEY = 'aff_sub3';
  private static AFF_SUB4_KEY = 'aff_sub4';
  private static AFF_SUB5_KEY = 'aff_sub5';
  private static APP_THEME_KEY = 'app_theme';
  // NATIVE CAMPAIGNS: ADDED - persisted native campaign configuration.
  private static ADUNIT_ID_KEY = 'native_adunit_id';
  private static LIMIT_KEY = 'native_campaign_limit';
  private static OPEN_IN_APP_KEY = 'native_open_in_app';

  private static CONFIG_KEY_PREFIX = 'mychips_endpoint_settings_';

  private static THEME_DARK = 'dark';
  private static THEME_LIGHT = 'light';

  //private static CONFIG_KEY_PREFIX = 'sdk_config_';
  //private static CONFIG_APP_THEME_KEY = 'sdk_config_app_theme';

  async setId(userId: string): Promise<void> {
     try {
       await AsyncStorage.setItem(UserService.USER_ID_KEY, userId);
     } catch (error) {
       console.error('Failed to set user ID', error);
     }
   }


   async getOrCreateId(): Promise<string> {
    try {
      let userId = await AsyncStorage.getItem(UserService.USER_ID_KEY);
      if (!userId) {
        userId = this.generateUUID();
        await this.setId(userId);
      }
      return userId;
    } catch (error) {
      console.error('Failed to get or create user ID', error);
      throw error;
    }
  }

  async setGaid(gaid: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.GAID_KEY, gaid);
    } catch (error) {
      console.error('Failed to set GAID', error);
    }
  }

  async getGaid(): Promise<string> {
    try {
      const gaid = await AsyncStorage.getItem(UserService.GAID_KEY);
      return gaid || '';
    } catch (error) {
      console.error('Failed to get GAID', error);
      return '';
    }
  }
  
  async setIdfa(idfa: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.IDFA_KEY, idfa);
    } catch (error) {
      console.error('Failed to set IDFA', error);
    }
  }

  async getIdfa(): Promise<string> {
    try {
      const idfa = await AsyncStorage.getItem(UserService.IDFA_KEY);
      return idfa || '';
    } catch (error) {
      console.error('Failed to get IDFA', error);
      return '';
    }
  }

  async setAge(age: number): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AGE_KEY, age.toString());
    } catch (error) {
      console.error('Failed to set age', error);
    }
  }

  async getAge(): Promise<number> {
    try {
      const age = await AsyncStorage.getItem(UserService.AGE_KEY);
      return age ? parseInt(age, 10) : -1;
    } catch (error) {
      console.error('Failed to get age', error);
      return -1;
    }
  }



  async setGender(gender: MCGenderEnum): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.GENDER_KEY, gender.toString());
    } catch (error) {
      console.error('Failed to set gender', error);
    }
  }

  async getGender(): Promise<string> {
    try {
      const gender = await AsyncStorage.getItem(UserService.GENDER_KEY);
      return gender || '';
    } catch (error) {
      console.error('Failed to get gender', error);
      return '';
    }
  }


  async setEmail(email: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.EMAIL_KEY, email);
    } catch (error) {
      console.error('Failed to set email', error);
    }
  }

  async getEmail(): Promise<string> {
    try {
      const email = await AsyncStorage.getItem(UserService.EMAIL_KEY);
      return email || '';
    } catch (error) {
      console.error('Failed to get email', error);
      return '';
    }
  }

  async setCurrentTotalCurrency(vc: number): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.CURRENCY_KEY, vc.toString());
    } catch (error) {
      console.error('Failed to set currency', error);
    }
  }

  async getCurrentTotalCurrency(): Promise<number> {
    try {
      const currency = await AsyncStorage.getItem(UserService.CURRENCY_KEY);
      return currency ? parseFloat(currency) : -1;
    } catch (error) {
      console.error('Failed to get currency', error);
      return -1;
    }
  }

  // NATIVE CAMPAIGNS: ADDED
  async setAdunitId(adunitId: string): Promise<void> {
    await AsyncStorage.setItem(UserService.ADUNIT_ID_KEY, adunitId);
  }

  async getAdunitId(): Promise<string> {
    return (await AsyncStorage.getItem(UserService.ADUNIT_ID_KEY)) ?? '';
  }

  async setLimit(limit: number): Promise<void> {
    const normalized = Math.min(50, Math.max(1, Math.trunc(limit)));
    await AsyncStorage.setItem(UserService.LIMIT_KEY, String(normalized));
  }

  async getLimit(): Promise<number> {
    const value = await AsyncStorage.getItem(UserService.LIMIT_KEY);
    return value ? Number.parseInt(value, 10) : 10;
  }

  async setOpenInApp(enabled: boolean): Promise<void> {
    await AsyncStorage.setItem(UserService.OPEN_IN_APP_KEY, String(enabled));
  }

  async getOpenInApp(): Promise<boolean> {
    return (await AsyncStorage.getItem(UserService.OPEN_IN_APP_KEY)) === 'true';
  }

  async setDarkMode(enabled: boolean | null): Promise<void> {
    try {
      await this.setConfig(
        UserService.APP_THEME_KEY,
        enabled === null
          ? null
          : enabled
            ? UserService.THEME_DARK
            : UserService.THEME_LIGHT
      );
    } catch (error) {
      console.error('Failed to set app theme', error);
    }
  }
  
  async getDarkMode(): Promise<boolean | null> {
    try {
      const appTheme = await this.getConfig(UserService.APP_THEME_KEY);

      if (appTheme === UserService.THEME_DARK) {
        return true;
      }

      if (appTheme === UserService.THEME_LIGHT) {
        return false;
      }

      return null;
    } catch (error) {
      console.error('Failed to get dark mode', error);
      return null;
    }
  }

  // aff_sub1 ~ aff_sub5
  async setAffSub1(sub1: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AFF_SUB1_KEY, sub1 ?? '');
    } catch (error) {
      console.error('Error saving aff_sub1:', error);
    }
  }

  async getAffSub1(): Promise<string> {
    try {
      const sub1 = await AsyncStorage.getItem(UserService.AFF_SUB1_KEY);
      return sub1 ?? '';
    } catch (error) {
      console.error('Error reading aff_sub1:', error);
      return '';
    }
  }

  async setAffSub2(sub2: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AFF_SUB2_KEY, sub2 ?? '');
    } catch (error) {
      console.error('Error saving aff_sub2:', error);
    }
  }

  async getAffSub2(): Promise<string> {
    try {
      const sub2 = await AsyncStorage.getItem(UserService.AFF_SUB2_KEY);
      return sub2 ?? '';
    } catch (error) {
      console.error('Error reading aff_sub2:', error);
      return '';
    }
  }

  async setAffSub3(sub3: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AFF_SUB3_KEY, sub3 ?? '');
    } catch (error) {
      console.error('Error saving aff_sub3:', error);
    }
  }

  async getAffSub3(): Promise<string> {
    try {
      const sub3 = await AsyncStorage.getItem(UserService.AFF_SUB3_KEY);
      return sub3 ?? '';
    } catch (error) {
      console.error('Error reading aff_sub3:', error);
      return '';
    }
  }

  async setAffSub4(sub4: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AFF_SUB4_KEY, sub4 ?? '');
    } catch (error) {
      console.error('Error saving aff_sub4:', error);
    }
  }

  async getAffSub4(): Promise<string> {
    try {
      const sub4 = await AsyncStorage.getItem(UserService.AFF_SUB4_KEY);
      return sub4 ?? '';
    } catch (error) {
      console.error('Error reading aff_sub4:', error);
      return '';
    }
  }

  async setAffSub5(sub5: string): Promise<void> {
    try {
      await AsyncStorage.setItem(UserService.AFF_SUB5_KEY, sub5 ?? '');
    } catch (error) {
      console.error('Error saving aff_sub5:', error);
    }
  }

  async getAffSub5(): Promise<string> {
    try {
      const sub5 = await AsyncStorage.getItem(UserService.AFF_SUB5_KEY);
      return sub5 ?? '';
    } catch (error) {
      console.error('Error reading aff_sub5:', error);
      return '';
    }
  }

  async setConfig(key: string, value: string | null): Promise<void> {
    const storageKey = `${UserService.CONFIG_KEY_PREFIX}${key}`;

    try {
      if (value === null) {
        await AsyncStorage.removeItem(storageKey);
      } else {
        await AsyncStorage.setItem(storageKey, value);
      }
    } catch (error) {
      console.error(`Failed to set config "${key}"`, error);
    }
  }

  async getConfig(key: string): Promise<string | null> {
    const storageKey = `${UserService.CONFIG_KEY_PREFIX}${key}`;

    try {
      return await AsyncStorage.getItem(storageKey);
    } catch (error) {
      console.error(`Failed to get config "${key}"`, error);
      return null;
    }
  }

  async getAllConfig(): Promise<Record<string, string>> {
    try {
      const keys = await AsyncStorage.getAllKeys();
      const configKeys = keys.filter((key) =>
        key.startsWith(UserService.CONFIG_KEY_PREFIX)
      );

      if (configKeys.length === 0) {
        return {};
      }

      const entries = await AsyncStorage.multiGet(configKeys);
      const result: Record<string, string> = {};

      for (const [fullKey, value] of entries) {
        if (value != null) {
          const key = fullKey.replace(UserService.CONFIG_KEY_PREFIX, '');
          result[key] = value;
        }
      }

      return result;
    } catch (error) {
      console.error('Failed to get all config', error);
      return {};
    }
  }

  private generateUUID(): string {
    // Generate a simple UUID
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
      const r = (Math.random() * 16) | 0;
      const v = c === 'x' ? r : (r & 0x3) | 0x8;
      return v.toString(16);
    });
  }
}