# Copyright 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
import mocker
import datetime

import appenginetestcase
import quartermile
import models

USER_A = { 'user_id' : 'A', 'container_id' : 'test' }
USER_B = { 'user_id' : 'B', 'container_id' : 'test' }

class QuartermileTests(appenginetestcase.AppEngineTestCase):
  
  ##### Utils #####
    
  def get_user(self, user_id, container_id):
    return models.User.gql('WHERE opensocial_id = :1 and container_id = :2',
        user_id, container_id).get()
    
  def new_team(self, name, count=0):
    team = models.Team(name=name, count=count)
    team.put()
    return team
    
  def get_team(self, team_name):
    return models.Team.gql('WHERE name = :1', team_name).get()
        
  def get_past_monthday(self, month, day):
    now = self.get_now()
    targetdate = now.replace(month=month, day=day, year=now.year)
    if targetdate > now:
      targetdate = targetdate.replace(year=targetdate.year - 1)
    return targetdate
    
  def get_now(self):
    return datetime.datetime.utcnow().replace(tzinfo = models.UTC())
    
  ##### Asserts #####
  
  def assert_db_entries_equal(self, a, b):
    self.assertTrue(a is not None)
    self.assertTrue(b is not None)
    self.assertEqual(a.key(), b.key())
    
  def assert_dates_equal(self, a, b):
    self.assertTrue(a is not None)
    self.assertTrue(b is not None)
    self.assertEqual(a.date(), b.date())
    
  ##### Tests #####
      
  def test_insert_new_user(self):
    self.assertTrue(self.get_user(**USER_A) is None)
    user = quartermile.user_get_or_insert(**USER_A)
    self.assert_db_entries_equal(self.get_user(**USER_A), user)
    
  def test_get_existing_user(self):
    self.assertTrue(self.get_user(**USER_A) is None)
    user_a = quartermile.user_get_or_insert(**USER_A)

    self.assertTrue(self.get_user(**USER_A) is not None)
    user_b = quartermile.user_get_or_insert(**USER_A)

    self.assert_db_entries_equal(user_a, user_b)
    self.assert_db_entries_equal(self.get_user(**USER_A), user_a)
    
  def test_count_team_members(self):
    new_team = self.new_team('Team')
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 0)
    
    user_a = quartermile.user_get_or_insert(**USER_A)
    quartermile.team_join(user_a, new_team)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 1)
    
    user_b = quartermile.user_get_or_insert(**USER_B)
    quartermile.team_join(user_b, new_team)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 2)
    
  def test_switching_teams_deletes_old_empty_team(self):
    self.assertTrue(self.get_team('Team A') is None)
    user = quartermile.user_get_or_insert(**USER_A)
    quartermile.team_create(user, 'Team A')
    self.assertTrue(self.get_team('Team A') is not None)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team A')), 1)
    
    self.assertTrue(self.get_team('Team B') is None)
    new_team = self.new_team('Team B')
    self.assertTrue(self.get_team('Team B') is not None)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team B')), 0)
        
    quartermile.team_join(user, new_team)
    self.assertTrue(self.get_team('Team A') is None)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team B')), 1)
    
  def test_max_team_members_enforced(self):
    mock = self.mocker.replace('quartermile.Settings')
    mock.MAX_TEAM_MEMBERS
    self.mocker.count(0, None)
    self.mocker.result(1)
    self.mocker.replay()
    
    new_team = self.new_team('Team')
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 0)
    
    user_a = quartermile.user_get_or_insert(**USER_A)
    quartermile.team_join(user_a, new_team)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 1)
    
    user_b = quartermile.user_get_or_insert(**USER_B)
    self.assertRaises(quartermile.ConstraintError, quartermile.team_join, 
                      user_b, new_team)
    self.assertEquals(quartermile.team_count_users(self.get_team('Team')), 1)

  def test_get_teams(self):
    team_1 = self.new_team('Team1')
    team_2 = self.new_team('Team2')
    
    single_team = quartermile.model_get_by_id(models.Team, team_1.team_id)
    self.assertTrue(isinstance(single_team, list))
    self.assertEqual(len(single_team), 1)
    self.assert_db_entries_equal(single_team[0], team_1)
    
    many_teams = quartermile.model_get_by_id(models.Team, 
                                             [team_1.team_id, team_2.team_id])
    self.assertTrue(isinstance(many_teams, list))
    self.assertEqual(len(many_teams), 2)
    self.assert_db_entries_equal(many_teams[0], team_1)
    self.assert_db_entries_equal(many_teams[1], team_2)
        
  def test_get_zero_team(self):
    team = quartermile.model_get_by_id(models.Team, [0])
    self.assertTrue(isinstance(team, list))
    self.assertEqual(len(team), 0)
    
  def test_get_interesting_teams(self):
    mock = self.mocker.replace('quartermile.Settings')
    mock.MAX_INTERESTING_TEAMS
    self.mocker.count(0, None)
    self.mocker.result(2)
    self.mocker.replay()
    
    team_1 = self.new_team('Team1', count=10)
    team_2 = self.new_team('Team2', count=9)
    team_3 = self.new_team('Team3', count=8)
    
    interesting_teams = quartermile.team_get_interesting()
    self.assertEquals(len(interesting_teams), 2)
    self.assert_db_entries_equal(interesting_teams[0], team_1)
    self.assert_db_entries_equal(interesting_teams[1], team_2)
    
    interesting_teams = quartermile.team_get_interesting(team_3.team_id)
    self.assertEquals(len(interesting_teams), 3)
    self.assert_db_entries_equal(interesting_teams[0], team_3)
    self.assert_db_entries_equal(interesting_teams[1], team_1)
    self.assert_db_entries_equal(interesting_teams[2], team_2)

  def check_activity(self, activity, text=None, distance=None, speed=None, 
      count=None, time=None):
    if text:
      self.assertEquals(activity.activity, text)
    if distance:
      self.assertAlmostEqual(activity.distance, distance)
    if speed:
      self.assertAlmostEqual(activity.speed, speed)
    if count:
      self.assertEquals(activity.count, count)
    if time:
      self.assert_dates_equal(activity.time, time)
      
  def test_create_activity(self):
    now = self.get_now()
    
    user = quartermile.user_get_or_insert(**USER_A)
    self.assertRaises(quartermile.ConstraintError, 
        quartermile.activity_create, user, 'Biked 10 miles yesterday')

    quartermile.team_create(user, 'Team A')
    
    activity_text = 'Biked 10 miles yesterday'
    act = quartermile.activity_create(user, activity_text)
    time = now - datetime.timedelta(days=1)
    self.check_activity(act, text='biked', distance=10.0, time=time)
    
    activity_text = 'Walked 4.5 miles in 20 minutes 2 days ago'
    act = quartermile.activity_create(user, activity_text)
    time = now - datetime.timedelta(days=2)
    self.check_activity(act, text='walked', distance=4.5, speed=13.5, time=time)
        
    activity_text = 'Swam 9 miles at 6mph on July 13'
    act = quartermile.activity_create(user, activity_text)
    time = self.get_past_monthday(7, 13)
    self.check_activity(act, text='swam', distance=9.0, speed=6.0, time=time)
    
    activity_text = 'Walked 1 mile yesterday'
    act = quartermile.activity_create(user, activity_text)
    time = now - datetime.timedelta(days=1)
    self.check_activity(act, text='walked', distance=1.0, time=time)