import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
import { Observable, throwError, BehaviorSubject, from } from 'rxjs';
import { retry, catchError, tap, map, take, switchMap } from 'rxjs/operators';
import { Urls } from "./urls";
import { Plugins } from '@capacitor/core';
import { User } from '../user.model';
import { AuthService } from '../auth/auth.service';
import { StorageService } from './storage.service';

export interface AuthResponseData {
    oss_token: string;
    oss_username: string;
}

@Injectable({
    providedIn: 'root'
})
export class UserService {
    usernamesession: any;
    private _user = new BehaviorSubject<User>(null);
    // API path
    base_path = Urls.base_url;
    

    
    constructor(
        private http: HttpClient,private authService: UserService,
        private storage:StorageService
    ) { }

    get userIsAuthenticated() {
      return this._user.asObservable().pipe(
        map(user => {
          console.log(user);
          if (user) {
           console.log(user);
            return !!user.token;
          } else {
            //console.log(user.token);
            return false;
          }
        })
      );

    }

    get token() {
      return this._user.asObservable().pipe(
        map(user => {
          if (user) {
            return user.token;
          } else {
            return null;
          }
        })
      );
    }

    get username() {
      return this._user.asObservable().pipe(
        map(user => {
          if (user) {
            return user.username;
          } else {
            return null;
          }
        })
      );
    }

    get usernametoken() {
      return this._user.asObservable().pipe(
        map(user => {
          if (user) {
            return user.username+user.token;
          } else {
            return null;
          }
        })
      );
    }

      get tGetCategoriesoken() {
        return this._user.asObservable().pipe(
          map(user => {
            if (user) {
              return user.token;
            } else {
              return null;
            }
          })
        );
      }

      autoLogin() {
        return from(Plugins.Storage.get({ key: 'authData' })).pipe(
          map(storedData => {
            if (!storedData || !storedData.value) {
              return null;
            }
            const parsedData = JSON.parse(storedData.value) as {
              oss_token: string;
              oss_username: string;
            };
           
            const user = new User(
              parsedData.oss_token,
              parsedData.oss_username,
            
            );
            console.log(user);
            return user;
          }),
          tap(user => {
            if (user) {
              this._user.next(user);
              //this.autoLogout(user.tokenDuration);
            }
          }),
          map(user => {
            return !!user;
          })
        );
      }
      
    // Http Options
    httpOptions = {
        headers: new HttpHeaders({
            'Content-Type': 'application/json'
        })
    }

    // Handle API errors
    handleError(error: HttpErrorResponse) {
        if (error.error instanceof ErrorEvent) {
            // A client-side or network error occurred. Handle it accordingly.
            console.error('An error occurred:', error.error.message);
        } else {
            // The backend returned an unsuccessful response code.
            // The response body may contain clues as to what went wrong,
            console.error(
                `Backend returned code ${error.status}, ` +
                `body was: ${error.error}`);
        }
        // return an observable with a user-facing error message
        return throwError(
            'Something bad happened; please try again later.');
    };


    // Create a new item
    createItem(item): Observable<any> {
        return this.http
            .post<any>(this.base_path, JSON.stringify(item), this.httpOptions)
            .pipe(
            retry(2),
            catchError(this.handleError)
            )
    }
    SignUp(item): Observable<any> {
      this.storage.set("username",item.oss_username);

      let authdata = {
        oss_username : item.oss_username
      }
      this.storeAuthData2.bind(authdata);

        return this.http
            .post<any>(this.base_path, item, this.httpOptions)
            .pipe(tap(this.storeAuthData2.bind(this)),
            retry(2),
            catchError(this.handleError)
            )
    }
    SignIn(item): Observable<any> {

      //Plugins.Storage.set({ key: 'username', value: item.oss_username });
      this.storage.set("username",item.oss_username);

      let authdata = {
        oss_username : item.oss_username
      }
      this.storeAuthData.bind(authdata);
      
        return this.http
            .post<any>(this.base_path, item, this.httpOptions)
            .pipe(tap(this.storeAuthData.bind(this)),
            retry(2),
            catchError(this.handleError)
            )
    }

    logout() {
      // if (this.activeLogoutTimer) {
      //   clearTimeout(this.activeLogoutTimer);
      // }
      this._user.next(null);
      Plugins.Storage.remove({ key: 'authData' });
      Plugins.Storage.remove({ key: 'username' });
      
    }

    storeAuthData(userData: AuthResponseData) {

      //this.storage.get("username").then(data=>{
        console.log(userData.oss_token);

        //if(userData.oss_token ! =='') {
          const datauser = JSON.stringify({
            oss_token: userData.oss_token,
            oss_username: userData.oss_username
          });
  
          const user = new User(
            userData.oss_token,
            userData.oss_username
           
          );
  
          this._user.next(user);
          Plugins.Storage.set({ key: 'authData', value: datauser });
        //}
       
        //},
        // error=>{console.log(error);});

    }

    storeAuthData2(userData: AuthResponseData) {

      //this.storage.get("username").then(data=>{
        //console.log(data,'lang');
        const datauser = JSON.stringify({
          oss_token: userData.oss_token,
          oss_username: userData.oss_username
        });

        const user = new User(
          userData.oss_token,
          userData.oss_username
         
        );

        this._user.next(user);
        Plugins.Storage.set({ key: 'authData', value: datauser });
        //},
        // error=>{console.log(error);});

    }
   
    getConsumption(item): Observable<any> {
      return from(Plugins.Storage.get({ key: 'authData' })).pipe(
        take(1),
        switchMap(storedData => {
        

          const parsedData = JSON.parse(storedData.value) as {
            oss_token: string;
            oss_username: string;
          };

          let body={
            request_category:'get_consumption',
            oss_language : item===1?'en':'ar',
            oss_username: parsedData.oss_username,
            oss_secret: parsedData.oss_token
          }

          return this.http
          .post<any>(this.base_path, body, this.httpOptions)
          .pipe(
          retry(2),
          catchError(this.handleError)
          )
        })
      );
    }

    getPackages(item): Observable<any> {
      return from(Plugins.Storage.get({ key: 'authData' })).pipe(
        take(1),
        switchMap(storedData => {
        

          const parsedData = JSON.parse(storedData.value) as {
            oss_token: string;
            oss_username: string;
          };

          let body={
            request_category:'get_services',
            oss_language : item===1?'en':'ar',
            oss_username: parsedData.oss_username,
            oss_secret: parsedData.oss_token
          }

          return this.http
          .post<any>(this.base_path, body, this.httpOptions)
          .pipe(
          retry(2),
          catchError(this.handleError)
          )
        })
      );
    }

    GetSupport(item): Observable<any> {
     // console.log(item);
     return from(Plugins.Storage.get({ key: 'authData' })).pipe(
        take(1),
        switchMap(storedData => {

          const parsedData = JSON.parse(storedData.value) as {
            oss_token: string;
            oss_username: string;
          };

          let body={
            request_category:'support_info',
            oss_language : item==1?'en':'ar',
            oss_username: parsedData.oss_username,
            oss_secret: parsedData.oss_token
          }

          return this.http
          .post<any>(this.base_path, body, this.httpOptions)
          .pipe(
          retry(2),
          catchError(this.handleError)
          )
        })
      );
    }

    getHotspot(item): Observable<any> {
      return from(Plugins.Storage.get({ key: 'authData' })).pipe(
        take(1),
        switchMap(storedData => {
        

          const parsedData = JSON.parse(storedData.value) as {
            oss_token: string;
            oss_username: string;
          };

          let body={
            request_category:'connect_hotspot',
            oss_language : item===1?'en':'ar',
            oss_username: parsedData.oss_username,
            oss_secret: parsedData.oss_token
          }

          return this.http
          .post<any>(this.base_path, body, this.httpOptions)
          .pipe(
          retry(2),
          catchError(this.handleError)
          )
        })
      );
    }

    // Get single any data by ID
    getItem(id): Observable<any> {
        return this.http
            .get<any>(this.base_path + '/' + id)
            .pipe(
            retry(2),
            catchError(this.handleError)
            )
    }

    
    updateItem(id, item): Observable<any> {
        return this.http
            .put<any>(this.base_path + '/' + id, JSON.stringify(item), this.httpOptions)
            .pipe(
            retry(2),
            catchError(this.handleError)
            )
    }

    // Delete item by id
    deleteItem(id) {
        return this.http
            .delete<any>(this.base_path + '/' + id, this.httpOptions)
            .pipe(
            retry(2),
            catchError(this.handleError)
            )
    }

    GoPro(item,code): Observable<any> {

      return from(Plugins.Storage.get({ key: 'authData' })).pipe(
        take(1),
        switchMap(storedData => {
        

          const parsedData = JSON.parse(storedData.value) as {
            oss_token: string;
            oss_username: string;
          };

          let body={
            request_category:'go_pro',
            oss_language : item==1?'en':'ar',
            oss_username: parsedData.oss_username,
            oss_secret: parsedData.oss_token,
            subscription_secret: code
          }

          return this.http
          .post<any>(this.base_path, body, this.httpOptions)
          .pipe(
          retry(2),
          catchError(this.handleError)
          )
        })
      );

     
  }

}