angular.module('dc.services', [])

.service('Session', function () {
  this.loggedIn = false;
  this.destroy = function () {
    this.loggedIn = false;
    this.username = null;
    this.firstName = null;
    this.lastName = null;
    this.email = null;
    this.phone = null;
    this.balance = null;
    this.authToken = null;
  };
})

.factory('AuthService', function($q, $http, $rootScope, Session) {
  var service = {
    login: function (email, password, isDesigner) {
      var authenticationData = {
          Username : email,
          Password : password,
      };
      var authenticationDetails = new AWSCognito.CognitoIdentityServiceProvider.AuthenticationDetails(authenticationData);
      var poolDataToUse = $rootScope.isDesignerSite ? designerPoolData : poolData;
      userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolDataToUse);
      var userData = {
          Username : email,
          Pool : userPool
      };
      var cognitoUser = new AWSCognito.CognitoIdentityServiceProvider.CognitoUser(userData);
      cognitoUser.authenticateUser(authenticationDetails, {
          onSuccess: function (result) {
              console.log('access token + ' + result.getAccessToken().getJwtToken());
              
              var cognitoUser = userPool.getCurrentUser();
              
              Session.loggedIn= true;
              Session.balance = 0.00;
              Session.authToken= result.idToken.jwtToken;
              Session.username = cognitoUser.username;

              $rootScope.$broadcast('auth-login-success');
          },

          onFailure: function(err) {
              console.log('Err: '+err);
              $rootScope.$broadcast('auth-login-fail', { errorMessage: err });
          },

      });
    },
    register: function (firstName, lastName, email, phone, password) {
      AWSCognito.config.region = 'eu-west-2'; //This is required to derive the endpoint
      
      var poolDataToUse = $rootScope.isDesignerSite ? designerPoolData : poolData;
        
      var userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolDataToUse);

      var attributeList = [];
      
      var attributeEmail = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserAttribute(email);

      userPool.signUp(email, password, attributeList, null, function(err, result){
          if (err) {
              setTimeout(function() {$rootScope.$broadcast('auth-register-fail', { errorMessage: err })}, 100);
              return;
          }
          cognitoUser = result.user;
          console.log('user name is ' + cognitoUser.getUsername());

          $rootScope.$broadcast('auth-register-phase1-success');

          
          Session.loggedIn= true;

      });
    },
    registerPhase2: function (firstName, lastName, email, phone, password) {
      // Now basically login - and then save the details
      var authenticationData = {
          Username : email,
          Password : password,
      };
      var authenticationDetails = new AWSCognito.CognitoIdentityServiceProvider.AuthenticationDetails(authenticationData);
      var poolDataToUse = $rootScope.isDesignerSite ? designerPoolData : poolData;
      userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolDataToUse);
      var userData = {
          Username : email,
          Pool : userPool
      };
      var cognitoUser = new AWSCognito.CognitoIdentityServiceProvider.CognitoUser(userData);
      cognitoUser.authenticateUser(authenticationDetails, {
          onSuccess: function (result) {
              console.log('access token + ' + result.getAccessToken().getJwtToken());
              
              var cognitoUser = userPool.getCurrentUser();
              
              Session.loggedIn= true;
              Session.balance = 0.00;
              Session.authToken= result.idToken.jwtToken;

              var authRequest = {
                method: 'POST',
                url: INVOKE_URL+'/user/create'+($rootScope.isDesignerSite?'/designer':''),
                headers: {
                  'Authorization':Session.authToken 
                },
                data: {email:email, firstName:firstName, lastName:lastName, phone:phone, isDesigner:$rootScope.isDesignerSite, deviceToken:$rootScope.deviceToken}
              }
              $http(authRequest).success(function(createUserResponse, status, headers, config) {
                if (createUserResponse.success) {
                  Session.loggedIn = true;
                  $rootScope.$broadcast('auth-register-success');
                } else {
                  Session.destroy();
                }
              }).error(function(createuserResponse) {
                setTimeout(function() {$rootScope.$broadcast('auth-register-fail', { errorMessage: createuserResponse })}, 100);
                Session.destroy();
              });
          },

          onFailure: function(err) {
              console.log('Err: '+err);
              $rootScope.$broadcast('auth-login-fail', { errorMessage: err });
          },
      });
    },
    details: function () {
      var poolDataToUse = $rootScope.isDesignerSite ? designerPoolData : poolData;
      var userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolDataToUse);
      var cognitoUser = userPool.getCurrentUser()
      
      if (cognitoUser != null) {
          cognitoUser.getSession(function(err, session) {
              if (err) {
                  alert(err);
                  return;
              }
              Session.loggedIn= true;
              Session.balance = 0.00;
              Session.authToken= session.idToken.jwtToken;
              console.log('session validity: ' + session.isValid());
              
              var authRequest = {
                method: 'GET',
                url: INVOKE_URL+'/user/details'+($rootScope.isDesignerSite?'/designer':''),
                headers: {
                  'Authorization':Session.authToken 
                }
              }
              $http(authRequest).success(function(getUserResponse, status, headers, config) {
                if (getUserResponse.success) {
                  Session.loggedIn = true;
                  Session.firstName = getUserResponse.firstName;
                  Session.lastName = getUserResponse.lastName;
                  Session.phone = getUserResponse.phone;
                  Session.email = getUserResponse.email;

                  $rootScope.$broadcast('auth-details-success');
                } else {
                  Session.destroy();
                }
              }).error(function(getUserResponse) {
                setTimeout(function() {$rootScope.$broadcast('auth-details-fail', { errorMessage: getUserResponse })}, 100);
                Session.destroy();
              });
          });
      }

    },
    balance: function () {
      if (Session.loggedIn != null) {
        var balanceRequest = {
          method: 'GET',
          url: INVOKE_URL+'/user/balance',
          headers: {
            'Authorization':Session.authToken 
          }
        }
        $http(balanceRequest).then(function(promoResponse) {
          if (promoResponse.data.success) {
            Session.balance = promoResponse.data.balance;
          }
        });
      } else {
        console.log("Cannot get balance - not logged in");
      }
    },
    logout: function () {
      var poolDataToUse = $rootScope.isDesignerSite ? designerPoolData : poolData;

      var userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolDataToUse);
      var cognitoUser = userPool.getCurrentUser()
      if (cognitoUser != null) {
        cognitoUser.signOut();
        Session.destroy();
        $rootScope.$broadcast('auth-logout-success');
      }
    }
  }
  return service;
})

.factory('DesignService', function($q, $http, Session) {

  var designMap = new Object();
  var pendingPayment = [];
  var pendingDesigner = [];
  var beingModelled = [];
  var pendingApproval = [];
  var inProduction = [];
  var completed = [];
  var approved = [];
  var cancelled = [];
  
  var service = {

    uploadFile: function(fileToUpload){
      if (!Session.loggedIn) {
        // do something
        alert("Not Logged On");
        return;
      }
      
      var deferred = $q.defer();
      
      $http.get(INVOKE_URL+"/access", {
            headers: {'Content-Type': 'application/json', 'filename': fileToUpload.name, 'Authorization': Session.authToken}
          }).success( function(accessResponse, status, headers, config) {
        if (accessResponse && accessResponse.url) {
          return $http.put(accessResponse.url, fileToUpload, {
            headers: {'Content-Type': 'application/octet-stream', 'filename': fileToUpload.name}
          })
          .success(function(uploadResponse){
            console.log("Success Uploading! Response: "+JSON.stringify(uploadResponse));
            deferred.resolve({url: accessResponse.url.substring(0, accessResponse.url.indexOf("?")), success: true})
          })
          .error(function(err){
            console.log("Error Uploading! Error: "+JSON.stringify(err));
            deferred.resolve({url: '', success: false, errorMessage: 'An error occurred uploading the file. '+err});
          });
        } else {
          console.log ("Bad");
        }
      }).error(function(err) {
        console.log ("Error: "+err);
      });
      return deferred.promise;
    },

    uploadModelFile: function(fileToUpload, designId){
      if (!Session.loggedIn) {
        // do something
        alert("Not Logged On");
        return;
      }
      
      var deferred = $q.defer();
      
      $http.get(INVOKE_URL+"/designer/access?designId="+designId, {
            headers: {'Content-Type': 'application/json', 'filename': fileToUpload.name, 'Authorization': Session.authToken}
          }).success( function(accessResponse, status, headers, config) {
        if (accessResponse && accessResponse.url) {
          return $http.put(accessResponse.url, fileToUpload, {
            headers: {'Content-Type': 'application/octet-stream', 'filename': fileToUpload.name}
          })
          .success(function(uploadResponse){
            console.log("Success Uploading! Response: "+JSON.stringify(uploadResponse));
            deferred.resolve({url: accessResponse.url.substring(0, accessResponse.url.indexOf("?")), success: true})
          })
          .error(function(err){
            console.log("Error Uploading! Error: "+JSON.stringify(err));
            deferred.resolve({url: '', success: false, errorMessage: 'An error occurred uploading the file. '+err});
          });
        } else {
          console.log ("Bad"); 
        }
      }).error(function(err) {
        console.log ("Error: "+err);
      });
      return deferred.promise;
    },
    uploadVideoFile: function(fileToUpload, designId){
      if (!Session.loggedIn) {
        // do something
        alert("Not Logged On");
        return;
      }
      
      var deferred = $q.defer();
      
      $http.get(INVOKE_URL+"/designer/access?designId="+designId, {
            headers: {'Content-Type': 'application/json', 'filename': fileToUpload.name, 'Authorization': Session.authToken}
          }).success( function(accessResponse, status, headers, config) {
        if (accessResponse && accessResponse.url) {
          return $http.put(accessResponse.url, fileToUpload, {
            headers: {'Content-Type': 'application/octet-stream', 'filename': fileToUpload.name}
          })
          .success(function(uploadResponse){
            console.log("Success Uploading! Response: "+JSON.stringify(uploadResponse));
            deferred.resolve({url: accessResponse.url.substring(0, accessResponse.url.indexOf("?")), success: true})
          })
          .error(function(err){
            console.log("Error Uploading! Error: "+JSON.stringify(err));
            deferred.resolve({url: '', success: false, errorMessage: 'An error occurred uploading the file. '+err});
          });
        } else {
          console.log ("Bad"); 
        }
      }).error(function(err) {
        console.log ("Error: "+err);
      });
      return deferred.promise;
    },
    setModelUrl: function (designId, modelUrl) {
      
      var setModelUrlRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/design/setmodel?designId='+designId+'&modelUrl='+modelUrl,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(setModelUrlRequest);
    },
    setVideoUrl: function (designId, videoUrl) {
      
      var setVideoUrlRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/design/setvideo?designId='+designId+'&videoUrl='+videoUrl,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(setVideoUrlRequest);
    },

    upload: function (fileToUpload) {
      $cordovaFileTransfer.upload("/upload", $scope.fileToUpload, {});
      return $q(function(resolve, reject) {
        resolve({success: true, url: 'http://25.media.tumblr.com/tumblr_m9we8taUh71rx93fyo1_1280.jpg'});
      });
    },
    submitDesign: function (name, fileUrl, circularBase, loopAtTop, height, material, additionalInfo, rotateBy) {
      return $http.post(
        INVOKE_URL+"/design", 
        {name:name, fileUrl:fileUrl, circularBase:circularBase, loopAtTop:loopAtTop, height:height, material:material, additionalInfo:additionalInfo, rotateBy:rotateBy},
        {
            headers: {'Content-Type': 'application/json', 'Authorization': Session.authToken}
        });
      
    },
    takeDesign: function (designId, userId) {
      
      var takeDesignRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/designs/takedesign?designId='+designId+'&userId='+userId,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(takeDesignRequest);
    },
    requestApprovalDesign: function (designId) {
      var takeDesignRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/design/requestapproval?designId='+designId,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(takeDesignRequest);
    },
    approveModel: function (designId) {
      var takeDesignRequest = {
        method: 'GET',
        url: INVOKE_URL+'/design/approve?designId='+designId,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(takeDesignRequest);
    },
    rejectModel: function (designId, rejectionReasons) {
      var takeDesignRequest = {
        method: 'GET',
        url: INVOKE_URL+'/design/reject?designId='+designId+'&rejectionReasons='+rejectionReasons,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(takeDesignRequest);
    },
    markAsInProduction: function (designId) {
      return $http.post(URL_PREFIX+'/api/designer/mark-as-in-production', {designId:designId});
    },
    markAsCompleted: function (designId) {
      return $http.post(URL_PREFIX+'/api/designer/mark-as-completed', {designId:designId});
    },
    resetDesigns: function () {
      pendingPayment = [];
      pendingDesigner = [];
      beingModelled = [];
      pendingApproval = [];
      inProduction = [];
      completed = [];
      approved = [];
      cancelled = [];
    },
    getDesign: function (designId) {
      return designMap[designId];
    },
    getDesigns: function () {
      return $http.get(INVOKE_URL+"/design"+nc(), {headers: {'Authorization': Session.authToken}}).success(
      function(designsResponse, status, headers, config) {
        if (designsResponse.success) {
          service.resetDesigns();
          for (var i = 0; i< designsResponse.designs.length; i++) {
            designMap[designsResponse.designs[i].designId] = designsResponse.designs[i];
            if (designsResponse.designs[i].status=='pendingPayment') {
              pendingPayment.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='pendingDesigner') {
              pendingDesigner.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='beingModelled') {
              beingModelled.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='pendingApproval') {
              pendingApproval.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='approved') {
              approved.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='inProduction') {
              inProduction.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='completed') {
              completed.push(designsResponse.designs[i]);
            } else if (designsResponse.designs[i].status=='cancelled') {
              cancelled.push(designsResponse.designs[i]);
            }
          }
          designsResponse.pendingDesigner = pendingDesigner;
          designsResponse.pendingPayment = pendingPayment;
          designsResponse.beingModelled = beingModelled;
          designsResponse.pendingApproval = pendingApproval;
          designsResponse.approved = approved;
          designsResponse.inProduction = inProduction;
          designsResponse.completed = completed;
          designsResponse.cancelled = cancelled;
        } else {
          
        }
      }).error(function(detailsResponse, status) {
        console.log("Error: "+detailsResponse);
      });
    },

    getNewDesigns: function () {
      var authRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/designs/pendingdesigner',
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(authRequest);
//      return $http.get(URL_PREFIX+'/api/designer/new-designs'+nc());
    },

    getMine: function () {
      return $http.get(URL_PREFIX+'/api/designer/mine'+nc());
    },

    getMineAsDesigner: function () {
      var getRequest = {
        method: 'GET',
        url: INVOKE_URL+'/designer/designs/mine',
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(getRequest);
    },
    
    getMineToModel: function () {
      return $http.get(URL_PREFIX+'/api/designer/mine-to-model'+nc());
    }

  }
  return service;
})
.factory('PushNotificationService', function($cordovaPush, $state, $rootScope, $q) {
  var service = {
    register: function() {
      var q = $q.defer();
      try {
        document.addEventListener("deviceready", function() {
          $rootScope.push = PushNotification.init({
            "android": {
              "senderID": 866915303120,
              "forceShow": true,
              "payload": {
                "content-available": "1"
              }
            },
            "IOS": {
              "badge": true,
              "sound": true,
              "alert": false
            },
            "browser": {
              pushServiceURL: "http://push.api.phonegap.com/v1/push"
            }
          });
          $rootScope.push.on('registration', function(data) {
            var id = data.registrationId;
            q.resolve(id);
          });
          $rootScope.push.on('notification', function(data) {
            redirectToScreen(data);
          });
          $rootScope.push.on('error', function(e) {
            console.log(e);
          });
        });
      } catch (e) {
        q.reject(e);
      }
      return q.promise;
    },
    unregister: function() {
      var q = $q.defer();
      if ($rootScope.push) {
        $rootScope.push.unregister(function (success) {
          q.resolve(success);
        }, function (error) {
          q.reject(error);
        });
      } else {
        q.reject("NULL REFERENCE");
      }
      return q.promise;
    },
    redirectToScreen: function(data) {
      var message = data.message;
      var title = data.title;
      var additionalData = data.additionalData;
      console.log(additionalData);
      var isForground = additionalData.foreground;
      // Implement your code to redirect to the screen that you want.
    }
  }
  return service;
})
.factory('TransactionService', function($q, $http, Session) {

  var service = {
    getMine: function () {
      var transactionsRequest = {
        method: 'GET',
        url: INVOKE_URL+'/cashier/transactions',
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(transactionsRequest);
    },
    applyPromo: function(promoCode, designId) {
      return $http.get(INVOKE_URL+"/promo"+nc() +"&promoCode="+promoCode+"&designId="+designId, {headers: {'Authorization': Session.authToken}});
    },
    completePurchase: function(designId, promoCode) {
      var completeRequest = {
        method: 'GET',
        url: INVOKE_URL+'/design/complete?designId='+designId+'&promoCode='+promoCode,
        headers: {
          'Authorization':Session.authToken 
        }
      }
      return $http(completeRequest);
    }
  }
  return service;
})

.factory('CashierService', function($q, $http, Session) {
  var service = {
    payNow: function (stripeToken, amount) {
      var payNowRequest = {
        method: 'POST',
        url: INVOKE_URL+'/cashier/paynow',
        headers: {
          'Authorization':Session.authToken 
        },
        data: {token:stripeToken.id, amount:amount}
      }
      return $http(payNowRequest);
    }
  }
  return service;
})

.factory('Camera', ['$q', function($q) {
  return {
    getPicture: function(options) {
      var q = $q.defer();

      navigator.camera.getPicture(function(result) {
        // Do any magic you need
        q.resolve(result);
      }, function(err) {
        q.reject(err);
      }, options);

      return q.promise;
    }
  }
}])

angular.module('ionic.utils', [])

.factory('$localStorage', ['$window', function($window) {
  return {
    set: function(key, value) {
      $window.localStorage[key] = value;
    },
    get: function(key, defaultValue) {
      return $window.localStorage[key] || defaultValue;
    },
    remove: function(key) {
      return $window.localStorage.removeItem([key]);
    },
    setObject: function(key, value) {
      $window.localStorage[key] = JSON.stringify(value);
    },
    getObject: function(key) {
      return JSON.parse($window.localStorage[key] || '{}');
    }
  }
}])

.factory('$sessionStorage', ['$window', function($window) {

  var canUseStorage = true;
  try {
    $window.sessionStorage.tmp = "tst";
  } catch (error) {
    canUseStorage = false;
  }

  return {
    localStorageAllowed: function() {
      return canUseStorage;
    },
    set: function(key, value) {
      if (canUseStorage) {
        $window.sessionStorage[key] = value;
      } else {
        createCookie(key, value, 1);
      }
    },
    get: function(key, defaultValue) {
      return this._get(key) || defaultValue;
    },
    _get: function(key) {
      if (canUseStorage) {
        return $window.sessionStorage[key];
      } else {
        return readCookie(key);
      }
    },
    remove: function(key) {
      if (canUseStorage) {
        return $window.sessionStorage.removeItem([key]);
      } else {
        eraseCookie(key);
      }
    },
    setObject: function(key, value) {
      this.set(key, JSON.stringify(value));
    },
    getObject: function(key) {
      return JSON.parse(this._get(key) || '{}');
    },
    getToken: function() {
      return this.get("tsp-tok");
    },
    setToken: function(tok) {
      return this.set("tsp-tok", tok);
    }
  }
}]);