import { Injectable } from '@angular/core';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
import { environment } from '@src/environments/environment';
import { first } from 'rxjs/operators';
import { ArgPair, Envelope, Phone, Syncable, User } from 'cic-client-meta';
import { AccountDetails } from '@app/_models';
import { LoggingService } from '@app/_services/logging.service';
import { TokenService } from '@app/_services/token.service';
import { MutableKeyStore, PGPSigner, Signer } from '@app/_pgp';
import { RegistryService } from '@app/_services/registry.service';
import { CICRegistry } from '@cicnet/cic-client';
import { personValidation, updateSyncable, vcardValidation } from '@app/_helpers';
import { add0x } from '@src/assets/js/ethtx/dist/hex';
import { KeystoreService } from '@app/_services/keystore.service';
const vCard = require('vcard-parser');

@Injectable({
  providedIn: 'root',
})
export class UserService {
  headers: HttpHeaders = new HttpHeaders({ 'x-cic-automerge': 'client' });
  keystore: MutableKeyStore;
  signer: Signer;
  registry: CICRegistry;

  accounts: Array<AccountDetails> = [];
  private accountsList: BehaviorSubject<Array<AccountDetails>> = new BehaviorSubject<
    Array<AccountDetails>
  >(this.accounts);
  accountsSubject: Observable<Array<AccountDetails>> = this.accountsList.asObservable();

  actions: Array<any> = [];
  private actionsList: BehaviorSubject<any> = new BehaviorSubject<any>(this.actions);
  actionsSubject: Observable<Array<any>> = this.actionsList.asObservable();

  categories: object = {};
  private categoriesList: BehaviorSubject<object> = new BehaviorSubject<object>(this.categories);
  categoriesSubject: Observable<object> = this.categoriesList.asObservable();

  constructor(
    private httpClient: HttpClient,
    private loggingService: LoggingService,
    private tokenService: TokenService
  ) {}

  async init(): Promise<void> {
    this.keystore = await KeystoreService.getKeystore();
    this.signer = new PGPSigner(this.keystore);
    this.registry = await RegistryService.getRegistry();
  }

  resetPin(phone: string): Observable<any> {
    const params: HttpParams = new HttpParams().set('phoneNumber', phone);
    return this.httpClient.put(`${environment.cicUssdUrl}/pin`, { params });
  }

  getAccountStatus(phone: string): Observable<any> {
    const params: HttpParams = new HttpParams().set('phoneNumber', phone);
    return this.httpClient.get(`${environment.cicUssdUrl}/pin`, { params });
  }

  getLockedAccounts(offset: number, limit: number): Observable<any> {
    return this.httpClient.get(`${environment.cicUssdUrl}/accounts/locked/${offset}/${limit}`);
  }

  async changeAccountInfo(
    address: string,
    name: string,
    phoneNumber: string,
    age: string,
    type: string,
    bio: string,
    gender: string,
    businessCategory: string,
    userLocation: string,
    location: string,
    locationType: string
  ): Promise<any> {
    const accountInfo: any = {
      vcard: {
        fn: [{}],
        n: [{}],
        tel: [{}],
      },
      location: {},
    };
    if (name) {
      accountInfo.vcard.fn[0].value = name;
      accountInfo.vcard.n[0].value = name.split(' ');
    }
    if (phoneNumber) {
      accountInfo.vcard.tel[0].value = phoneNumber;
    }
    if (bio) {
      accountInfo.products = [bio];
    }
    if (gender) {
      accountInfo.gender = gender;
    }
    if (age) {
      accountInfo.age = age;
    }
    if (type) {
      accountInfo.type = type;
    }
    if (businessCategory) {
      accountInfo.category = businessCategory;
    }
    if (location) {
      accountInfo.location.area = location;
    }
    if (userLocation) {
      accountInfo.location.area_name = userLocation;
    }
    if (locationType) {
      accountInfo.location.area_type = locationType;
    }
    await vcardValidation(accountInfo.vcard);
    accountInfo.vcard = btoa(vCard.generate(accountInfo.vcard));
    const accountKey: string = await User.toKey(address);
    this.getAccountDetailsFromMeta(accountKey)
      .pipe(first())
      .subscribe(
        async (res) => {
          const syncableAccount: Syncable = Envelope.fromJSON(JSON.stringify(res)).unwrap();
          const update: Array<ArgPair> = [];
          for (const prop of Object.keys(accountInfo)) {
            update.push(new ArgPair(prop, accountInfo[prop]));
          }
          updateSyncable(update, 'client-branch', syncableAccount);
          await personValidation(syncableAccount.m.data);
          await this.updateMeta(syncableAccount, accountKey, this.headers);
        },
        async (error) => {
          this.loggingService.sendErrorLevelMessage(
            'Cannot find account info in meta service',
            this,
            { error }
          );
          const syncableAccount: Syncable = new Syncable(accountKey, accountInfo);
          await this.updateMeta(syncableAccount, accountKey, this.headers);
        }
      );
    return accountKey;
  }

  async updateMeta(
    syncableAccount: Syncable,
    accountKey: string,
    headers: HttpHeaders
  ): Promise<any> {
    const envelope: Envelope = await this.wrap(syncableAccount, this.signer);
    const reqBody: string = envelope.toJSON();
    this.httpClient
      .put(`${environment.cicMetaUrl}/${accountKey}`, reqBody, { headers })
      .pipe(first())
      .subscribe((res) => {
        this.loggingService.sendInfoLevelMessage(`Response: ${res}`);
      });
  }

  getActions(): void {
    this.httpClient
      .get(`${environment.cicCacheUrl}/actions`)
      .pipe(first())
      .subscribe((res) => this.actionsList.next(res));
  }

  getActionById(id: string): Observable<any> {
    return this.httpClient.get(`${environment.cicCacheUrl}/actions/${id}`);
  }

  approveAction(id: string): Observable<any> {
    return this.httpClient.post(`${environment.cicCacheUrl}/actions/${id}`, { approval: true });
  }

  revokeAction(id: string): Observable<any> {
    return this.httpClient.post(`${environment.cicCacheUrl}/actions/${id}`, { approval: false });
  }

  getAccountDetailsFromMeta(userKey: string): Observable<any> {
    return this.httpClient.get(`${environment.cicMetaUrl}/${userKey}`, { headers: this.headers });
  }

  wrap(syncable: Syncable, signer: Signer): Promise<Envelope> {
    return new Promise<Envelope>(async (resolve, reject) => {
      syncable.setSigner(signer);
      syncable.onwrap = async (env) => {
        if (env === undefined) {
          reject();
          return;
        }
        resolve(env);
      };
      await syncable.sign();
    });
  }

  async loadAccounts(limit: number = 100, offset: number = 0): Promise<void> {
    try {
      const accountRegistry = await RegistryService.getAccountRegistry();
      const accountAddresses: Array<string> = await accountRegistry.last(offset + limit);
      this.loggingService.sendInfoLevelMessage(accountAddresses);
      if (typeof Worker !== 'undefined') {
        const worker = new Worker('@app/_workers/fetch-accounts.worker', { type: 'module' });
        worker.onmessage = ({ data }) => {
          this.tokenService.load.subscribe(async (status: boolean) => {
            if (status) {
              data.balance = await this.tokenService.getTokenBalance(
                data.identities.evm[`bloxberg:${environment.bloxbergChainId}`][0]
              );
            }
          });
          this.addAccount(data, limit);
        };
        worker.postMessage({
          addresses: accountAddresses.slice(offset, offset + limit),
          url: environment.cicMetaUrl,
        });
      } else {
        this.loggingService.sendInfoLevelMessage(
          'Web workers are not supported in this environment'
        );
        for (const accountAddress of accountAddresses.slice(offset, offset + limit)) {
          await this.getAccountByAddress(accountAddress, limit);
        }
      }
    } catch (error) {
      this.loggingService.sendErrorLevelMessage('Unable to load accounts.', 'user.service', error);
      throw error;
    }
  }

  async getAccountByAddress(
    accountAddress: string,
    limit: number = 100
  ): Promise<Observable<AccountDetails>> {
    const accountSubject: Subject<any> = new Subject<any>();
    this.getAccountDetailsFromMeta(await User.toKey(add0x(accountAddress)))
      .pipe(first())
      .subscribe(async (res) => {
        const account: Syncable = Envelope.fromJSON(JSON.stringify(res)).unwrap();
        const accountInfo = account.m.data;
        await personValidation(accountInfo);
        this.tokenService.load.subscribe(async (status: boolean) => {
          if (status) {
            accountInfo.balance = await this.tokenService.getTokenBalance(
              accountInfo.identities.evm[`bloxberg:${environment.bloxbergChainId}`][0]
            );
          }
        });
        accountInfo.vcard = vCard.parse(atob(accountInfo.vcard));
        await vcardValidation(accountInfo.vcard);
        this.addAccount(accountInfo, limit);
        accountSubject.next(accountInfo);
      });
    return accountSubject.asObservable();
  }

  async getAccountByPhone(
    phoneNumber: string,
    limit: number = 100
  ): Promise<Observable<AccountDetails>> {
    const accountSubject: Subject<any> = new Subject<any>();
    this.getAccountDetailsFromMeta(await Phone.toKey(phoneNumber))
      .pipe(first())
      .subscribe(async (res) => {
        const response: Syncable = Envelope.fromJSON(JSON.stringify(res)).unwrap();
        const address: string = response.m.data;
        const account: Observable<AccountDetails> = await this.getAccountByAddress(address, limit);
        account.subscribe((result) => {
          accountSubject.next(result);
        });
      });
    return accountSubject.asObservable();
  }

  resetAccountsList(): void {
    this.accounts = [];
    this.accountsList.next(this.accounts);
  }

  getCategories(): void {
    this.httpClient
      .get(`${environment.cicMetaUrl}/categories`)
      .pipe(first())
      .subscribe((res: object) => this.categoriesList.next(res));
  }

  getCategoryByProduct(product: string, categories: object): string {
    const keywords = product.toLowerCase().split(' ');
    for (const keyword of keywords) {
      const queriedCategory: string = Object.keys(categories).find((key) =>
        categories[key].includes(keyword)
      );
      if (queriedCategory) {
        return queriedCategory;
      }
    }
    return 'other';
  }

  getAccountTypes(): Observable<any> {
    return this.httpClient.get(`${environment.cicMetaUrl}/accounttypes`);
  }

  getTransactionTypes(): Observable<any> {
    return this.httpClient.get(`${environment.cicMetaUrl}/transactiontypes`);
  }

  getGenders(): Observable<any> {
    return this.httpClient.get(`${environment.cicMetaUrl}/genders`);
  }

  addAccount(account: AccountDetails, cacheSize: number): void {
    const savedIndex = this.accounts.findIndex(
      (acc) =>
        acc.identities.evm[`bloxberg:${environment.bloxbergChainId}`][0] ===
        account.identities.evm[`bloxberg:${environment.bloxbergChainId}`][0]
    );
    if (savedIndex === 0) {
      return;
    }
    if (savedIndex > 0) {
      this.accounts.splice(savedIndex, 1);
    }
    this.accounts.unshift(account);
    if (this.accounts.length > cacheSize) {
      this.accounts.length = Math.min(this.accounts.length, cacheSize);
    }
    this.accountsList.next(this.accounts);
  }
}