//
//  GTMABAddressBook.m
//
//  Copyright 2008 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 "GTMABAddressBook.h"
#import "GTMTypeCasting.h"

#if GTM_IPHONE_SDK
#import <UIKit/UIKit.h>
#else  // GTM_IPHONE_SDK
#import <Cocoa/Cocoa.h>
#endif  // GTM_IPHONE_SDK

NSString *const kGTMABUnknownPropertyName = @"UNKNOWN_PROPERTY";

typedef struct {
  GTMABPropertyType pType;
  Class class;
} TypeClassNameMap;

@interface GTMABMultiValue ()
- (unsigned long*)mutations;
@end

@interface GTMABMutableMultiValue ()
// Checks to see if a value is a valid type to be stored in this multivalue
- (BOOL)checkValueType:(id)value;
@end

@interface GTMABMultiValueEnumerator : NSEnumerator {
 @private
  GTM_WEAK ABMultiValueRef ref_;  // ref_ cached from enumeree_
  GTMABMultiValue *enumeree_;
  unsigned long mutations_;
  NSUInteger count_;
  NSUInteger index_;
  BOOL useLabels_;
}
+ (id)valueEnumeratorFor:(GTMABMultiValue*)enumeree;
+ (id)labelEnumeratorFor:(GTMABMultiValue*)enumeree;
- (id)initWithEnumeree:(GTMABMultiValue*)enumeree useLabels:(BOOL)useLabels;
- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state
                                  objects:(id *)stackbuf
                                    count:(NSUInteger)len;
@end

@implementation GTMABAddressBook
+ (GTMABAddressBook *)addressBook {
  return [[[self alloc] init] autorelease];
}

- (id)init {
  if ((self = [super init])) {
#if GTM_IPHONE_SDK
    CFErrorRef error = nil;
    addressBook_ = ABAddressBookCreateWithOptions(NULL, &error);
    if (error) {
      _GTMDevLog(@"ABAddressBookCreate: %@", error);
      CFRelease(error);
    }
#else  // GTM_IPHONE_SDK
    addressBook_ = ABGetSharedAddressBook();
    CFRetain(addressBook_);
#endif  // GTM_IPHONE_SDK
    if (!addressBook_) {
      // COV_NF_START
      [self release];
      self = nil;
      // COV_NF_END
    }
  }
  return self;
}

- (void)dealloc {
  if (addressBook_) {
    CFRelease(addressBook_);
  }
  [super dealloc];
}

- (BOOL)save {
#if GTM_IPHONE_SDK
  CFErrorRef cfError = NULL;
  bool wasGood = ABAddressBookSave(addressBook_, &cfError);
  if (!wasGood) {
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = ABSave(addressBook_);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (BOOL)hasUnsavedChanges {
  bool hasUnsavedChanges;
#if GTM_IPHONE_SDK
  hasUnsavedChanges = ABAddressBookHasUnsavedChanges(addressBook_);
#else  // GTM_IPHONE_SDK
  hasUnsavedChanges = ABHasUnsavedChanges(addressBook_);
#endif  // GTM_IPHONE_SDK
  return hasUnsavedChanges ? YES : NO;
}

- (BOOL)addRecord:(GTMABRecord *)record {
  // Note: we check for bad data here because of radar
  // 6201258 Adding a NULL record using ABAddressBookAddRecord crashes
  if (!record) return NO;
#if GTM_IPHONE_SDK
  CFErrorRef cfError = NULL;
  bool wasGood = ABAddressBookAddRecord(addressBook_,
                                        [record recordRef], &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = ABAddRecord(addressBook_, [record recordRef]);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (BOOL)removeRecord:(GTMABRecord *)record {
  // Note: we check for bad data here because of radar
  // 6201276 Removing a NULL record using ABAddressBookRemoveRecord crashes
  if (!record) return NO;
#if GTM_IPHONE_SDK
  CFErrorRef cfError = NULL;
  bool wasGood = ABAddressBookRemoveRecord(addressBook_,
                                           [record recordRef], &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  GTMABRecordID recID = [record recordID];
  ABRecordRef ref = ABCopyRecordForUniqueId(addressBook_, (CFStringRef)recID);
  bool wasGood = NO;
  if (ref) {
    wasGood = ABRemoveRecord(addressBook_, [record recordRef]);
    CFRelease(ref);
  }
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (NSArray *)people {
#if GTM_IPHONE_SDK
  NSArray *people
    = GTMCFAutorelease(ABAddressBookCopyArrayOfAllPeople(addressBook_));
#else  // GTM_IPHONE_SDK
  NSArray *people
    = GTMCFAutorelease(ABCopyArrayOfAllPeople(addressBook_));
#endif  // GTM_IPHONE_SDK
  NSMutableArray *result = [NSMutableArray arrayWithCapacity:[people count]];
  id person;
  for (person in people) {
    [result addObject:[GTMABPerson recordWithRecord:person]];
  }
  return result;
}

- (NSArray *)groups {
#if GTM_IPHONE_SDK
  NSArray *groups
    = GTMCFAutorelease(ABAddressBookCopyArrayOfAllGroups(addressBook_));
#else  // GTM_IPHONE_SDK
  NSArray *groups
    = GTMCFAutorelease(ABCopyArrayOfAllGroups(addressBook_));
#endif  // GTM_IPHONE_SDK
  NSMutableArray *result = [NSMutableArray arrayWithCapacity:[groups count]];
  id group;
  for (group in groups) {
    [result addObject:[GTMABGroup recordWithRecord:group]];
  }
  return result;
}

- (ABAddressBookRef)addressBookRef {
  return addressBook_;
}

- (GTMABPerson *)personForId:(GTMABRecordID)uniqueId {
  GTMABPerson *person = nil;
#if GTM_IPHONE_SDK
  ABRecordRef ref = ABAddressBookGetPersonWithRecordID(addressBook_, uniqueId);
#else  // GTM_IPHONE_SDK
  ABRecordRef ref = ABCopyRecordForUniqueId(addressBook_,
                                            (CFStringRef)uniqueId);
#endif  // GTM_IPHONE_SDK
  if (ref) {
    person = [GTMABPerson recordWithRecord:ref];
  }
  return person;
}

- (GTMABGroup *)groupForId:(GTMABRecordID)uniqueId {
  GTMABGroup *group = nil;
#if GTM_IPHONE_SDK
  ABRecordRef ref = ABAddressBookGetGroupWithRecordID(addressBook_, uniqueId);
#else  // GTM_IPHONE_SDK
  ABRecordRef ref = ABCopyRecordForUniqueId(addressBook_,
                                            (CFStringRef)uniqueId);
#endif  // GTM_IPHONE_SDK
  if (ref) {
    group = [GTMABGroup recordWithRecord:ref];
  }
  return group;
}

// Performs a prefix search on the composite names of people in an address book
// and returns an array of persons that match the search criteria.
- (NSArray *)peopleWithCompositeNameWithPrefix:(NSString *)prefix {
#if GTM_IPHONE_SDK
  NSArray *people =
    GTMCFAutorelease(ABAddressBookCopyPeopleWithName(addressBook_,
                                                     (CFStringRef)prefix));
  NSMutableArray *gtmPeople = [NSMutableArray arrayWithCapacity:[people count]];
  id person;
  for (person in people) {
    GTMABPerson *gtmPerson = [GTMABPerson recordWithRecord:person];
    [gtmPeople addObject:gtmPerson];
  }
  return gtmPeople;
#else
  // TODO(dmaclach): Change over to recordsMatchingSearchElement as an
  // optimization?
  // TODO(dmaclach): Make this match the way that the iPhone does it (by
  // checking both first and last names) and adding unittests for all this.
  NSArray *people = [self people];
  NSMutableArray *foundPeople = [NSMutableArray array];
  GTMABPerson *person;
  for (person in people) {
    NSString *compositeName = [person compositeName];
    NSRange range = [compositeName rangeOfString:prefix
                                         options:(NSCaseInsensitiveSearch
                                                  | NSDiacriticInsensitiveSearch
                                                  | NSWidthInsensitiveSearch
                                                  | NSAnchoredSearch)];
    if (range.location != NSNotFound) {
      [foundPeople addObject:person];
    }
  }
  return foundPeople;
#endif
}

// Performs a prefix search on the composite names of groups in an address book
// and returns an array of groups that match the search criteria.
- (NSArray *)groupsWithCompositeNameWithPrefix:(NSString *)prefix {
  NSArray *groups = [self groups];
  NSMutableArray *foundGroups = [NSMutableArray array];
  GTMABGroup *group;
  for (group in groups) {
    NSString *compositeName = [group compositeName];
    NSRange range = [compositeName rangeOfString:prefix
                                         options:(NSCaseInsensitiveSearch
                                                  | NSDiacriticInsensitiveSearch
                                                  | NSWidthInsensitiveSearch
                                                  | NSAnchoredSearch)];
    if (range.location != NSNotFound) {
      [foundGroups addObject:group];
    }
  }
  return foundGroups;
}

+ (NSString *)localizedLabel:(NSString *)label {
#if GTM_IPHONE_SDK
  return GTMCFAutorelease(ABAddressBookCopyLocalizedLabel((CFStringRef)label));
#else  // GTM_IPHONE_SDK
  return GTMCFAutorelease(ABCopyLocalizedPropertyOrLabel((CFStringRef)label));
#endif  // GTM_IPHONE_SDK
}

@end

@implementation GTMABRecord
+ (id)recordWithRecord:(ABRecordRef)record {
  return [[[self alloc] initWithRecord:record] autorelease];
}

- (id)initWithRecord:(ABRecordRef)record {
  if ((self = [super init])) {
    if ([self class] == [GTMABRecord class]) {
      [self autorelease];
      [self doesNotRecognizeSelector:_cmd];
    }
    if (!record) {
      [self release];
      self = nil;
    } else {
      record_ = (ABRecordRef)CFRetain(record);
    }
  }
  return self;
}

- (NSUInteger)hash {
  // This really isn't completely valid due to
  // 6203836 ABRecords hash to their address
  // but it's the best we can do without knowing what properties
  // are in a record, and we don't have an API for that.
  return CFHash(record_);
}

- (BOOL)isEqual:(id)object {
  // This really isn't completely valid due to
  // 6203836 ABRecords hash to their address
  // but it's the best we can do without knowing what properties
  // are in a record, and we don't have an API for that.
  return [object respondsToSelector:@selector(recordRef)]
    && CFEqual(record_, [object recordRef]);
}

- (void)dealloc {
  if (record_) {
    CFRelease(record_);
  }
  [super dealloc];
}

- (ABRecordRef)recordRef {
  return record_;
}

- (GTMABRecordID)recordID {
#if GTM_IPHONE_SDK
  return ABRecordGetRecordID(record_);
#else  // GTM_IPHONE_SDK
  return GTMCFAutorelease(ABRecordCopyUniqueId(record_));
#endif  // GTM_IPHONE_SDK
}

- (id)valueForProperty:(GTMABPropertyID)property {
#if GTM_IPHONE_SDK
  id value = GTMCFAutorelease(ABRecordCopyValue(record_, property));
#else  // GTM_IPHONE_SDK
  id value = GTMCFAutorelease(ABRecordCopyValue(record_, (CFStringRef)property));
#endif  // GTM_IPHONE_SDK
  if (value) {
    if ([[self class] typeOfProperty:property] & kABMultiValueMask) {
      value = [[[GTMABMultiValue alloc]
                initWithMultiValue:(ABMultiValueRef)value] autorelease];
    }
  }
  return value;
}

- (BOOL)setValue:(id)value forProperty:(GTMABPropertyID)property {
  if (!value) return NO;
  // We check the type here because of
  // Radar 6201046 ABRecordSetValue returns true even if you pass in a bad type
  //               for a value
  TypeClassNameMap fullTypeMap[] = {
    { kGTMABStringPropertyType, [NSString class] },
    { kGTMABIntegerPropertyType, [NSNumber class] },
    { kGTMABRealPropertyType, [NSNumber class] },
    { kGTMABDateTimePropertyType, [NSDate class] },
    { kGTMABDictionaryPropertyType, [NSDictionary class] },
    { kGTMABMultiStringPropertyType, [GTMABMultiValue class] },
    { kGTMABMultiRealPropertyType, [GTMABMultiValue class] },
    { kGTMABMultiDateTimePropertyType, [GTMABMultiValue class] },
    { kGTMABMultiDictionaryPropertyType, [GTMABMultiValue class] }
  };
  GTMABPropertyType type = [[self class] typeOfProperty:property];
  BOOL wasFound = NO;
  for (size_t i = 0; i < sizeof(fullTypeMap) / sizeof(TypeClassNameMap); ++i) {
    if (fullTypeMap[i].pType == type) {
      wasFound = YES;
      if (![[value class] isSubclassOfClass:fullTypeMap[i].class]) {
        return NO;
      }
    }
  }
  if (!wasFound) {
    return NO;
  }
  if (type & kABMultiValueMask) {
    value = (id)[value multiValueRef];
  }
#if GTM_IPHONE_SDK
  CFErrorRef cfError = nil;
  bool wasGood = ABRecordSetValue(record_, property,
                                  (CFTypeRef)value, &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = ABRecordSetValue(record_, (CFStringRef)property, (CFTypeRef)value);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (BOOL)removeValueForProperty:(GTMABPropertyID)property {
#if GTM_IPHONE_SDK
  CFErrorRef cfError = nil;
  // We check to see if the value is in the property because of:
  // Radar 6201005 ABRecordRemoveValue returns true for value that aren't
  //               in the record
  id value = [self valueForProperty:property];
  bool wasGood = value && ABRecordRemoveValue(record_, property, &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  id value = [self valueForProperty:property];
  bool wasGood = value && ABRecordRemoveValue(record_, (CFStringRef)property);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

// COV_NF_START
// All of these methods are to be overridden by their subclasses

- (NSString *)compositeName {
  [self doesNotRecognizeSelector:_cmd];
  return nil;
}

+ (GTMABPropertyType)typeOfProperty:(GTMABPropertyID)property {
  [self doesNotRecognizeSelector:_cmd];
  return kGTMABInvalidPropertyType;
}

+ (NSString *)localizedPropertyName:(GTMABPropertyID)property {
  [self doesNotRecognizeSelector:_cmd];
  return nil;
}
// COV_NF_END
@end

@implementation GTMABPerson

+ (GTMABPerson *)personWithFirstName:(NSString *)first
                            lastName:(NSString *)last {
  GTMABPerson *person = [[[self alloc] init] autorelease];
  if (person) {
    BOOL isGood = YES;
    if (first) {
      isGood = [person setValue:first
                    forProperty:kGTMABPersonFirstNameProperty];
    }
    if (isGood && last) {
      isGood = [person setValue:last forProperty:kGTMABPersonLastNameProperty];
    }
    if (!isGood) {
      // COV_NF_START
      // Marked as NF because I don't know how to force an error
      person = nil;
      // COV_NF_END
    }
  }
  return person;
}

- (id)init {
  ABRecordRef person = ABPersonCreate();
  self = [super initWithRecord:person];
  if (person) {
    CFRelease(person);
  }
  return self;
}

- (BOOL)setImageData:(NSData *)data {
#if GTM_IPHONE_SDK
  CFErrorRef cfError = NULL;
  bool wasGood = NO;
  if (!data) {
    wasGood = ABPersonRemoveImageData([self recordRef], &cfError);
  } else {
    // We verify that the data is good because of:
    // Radar 6202868 ABPersonSetImageData should validate image data
    UIImage *image = [UIImage imageWithData:data];
    wasGood = image && ABPersonSetImageData([self recordRef],
                                            (CFDataRef)data, &cfError);
  }
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = YES;
  if (data) {
    NSImage *image = [[[NSImage alloc] initWithData:data] autorelease];
    wasGood = image != nil;
  }
  wasGood = wasGood && ABPersonSetImageData([self recordRef], (CFDataRef)data);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (GTMABImage *)image {
  NSData *data = [self imageData];
#if GTM_IPHONE_SDK
  return [UIImage imageWithData:data];
#else  // GTM_IPHONE_SDK
  return [[[NSImage alloc] initWithData:data] autorelease];
#endif  // GTM_IPHONE_SDK
}

- (BOOL)setImage:(GTMABImage *)image {
#if GTM_IPHONE_SDK
  NSData *data = UIImagePNGRepresentation(image);
#else  // GTM_IPHONE_SDK
  NSData *data = [image TIFFRepresentation];
#endif  // GTM_IPHONE_SDK
  return [self setImageData:data];
}

- (NSData *)imageData {
  return GTMCFAutorelease(ABPersonCopyImageData([self recordRef]));
}

- (NSString *)compositeName {
#if GTM_IPHONE_SDK
  return GTMCFAutorelease(ABRecordCopyCompositeName([self recordRef]));
#else  // GTM_IPHONE_SDK
  NSNumber *nsFlags = [self valueForProperty:kABPersonFlags];
  NSInteger flags = [nsFlags longValue];
  NSString *compositeName = nil;
  if (flags & kABShowAsCompany) {
    compositeName = [self valueForProperty:kABOrganizationProperty];
  } else {
    NSString *firstName = [self valueForProperty:kGTMABPersonFirstNameProperty];
    NSString *lastName = [self valueForProperty:kGTMABPersonLastNameProperty];

    if (firstName && lastName) {
      GTMABPersonCompositeNameFormat format;
      if (flags & kABFirstNameFirst) {
        format = kABPersonCompositeNameFormatFirstNameFirst;
      } else if (flags & kABLastNameFirst) {
        format = kABPersonCompositeNameFormatLastNameFirst;
      } else {
        format = [[self class] compositeNameFormat];
      }
      if (format == kABPersonCompositeNameFormatLastNameFirst) {
        NSString *tempStr = lastName;
        lastName = firstName;
        firstName = tempStr;
      }
      compositeName = [NSString stringWithFormat:@"%@ %@", firstName, lastName];
    } else if (firstName) {
      compositeName = firstName;
    } else if (lastName) {
      compositeName = lastName;
    } else {
      compositeName = @"";
    }
  }

  return compositeName;
#endif  // GTM_IPHONE_SDK
}

- (NSString *)description {
#if GTM_IPHONE_SDK
  return [NSString stringWithFormat:@"%@ %@ %@ %d",
          [self class],
          [self valueForProperty:kGTMABPersonFirstNameProperty],
          [self valueForProperty:kGTMABPersonLastNameProperty],
          [self recordID]];
#else  // GTM_IPHONE_SDK
  return [NSString stringWithFormat:@"%@ %@ %@ %@",
          [self class],
          [self valueForProperty:kGTMABPersonFirstNameProperty],
          [self valueForProperty:kGTMABPersonLastNameProperty],
          [self recordID]];
#endif  // GTM_IPHONE_SDK
}

+ (NSString *)localizedPropertyName:(GTMABPropertyID)property {
#if GTM_IPHONE_SDK
  return GTMCFAutorelease(ABPersonCopyLocalizedPropertyName(property));
#else  // GTM_IPHONE_SDK
  return ABLocalizedPropertyOrLabel(property);
#endif  // GTM_IPHONE_SDK
}

+ (GTMABPersonCompositeNameFormat)compositeNameFormat {
#if GTM_IPHONE_SDK
  #if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
    return ABPersonGetCompositeNameFormat();
  #else
    return ABPersonGetCompositeNameFormatForRecord(NULL);
  #endif  // __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
#else  // GTM_IPHONE_SDK
  NSInteger nameOrdering
    = [[ABAddressBook sharedAddressBook] defaultNameOrdering];
  return nameOrdering == kABFirstNameFirst ?
    kABPersonCompositeNameFormatFirstNameFirst :
    kABPersonCompositeNameFormatLastNameFirst;
#endif  // GTM_IPHONE_SDK
}

+ (GTMABPropertyType)typeOfProperty:(GTMABPropertyID)property {
#if GTM_IPHONE_SDK
  return ABPersonGetTypeOfProperty(property);
#else  // GTM_IPHONE_SDK
  return ABTypeOfProperty([[GTMABAddressBook addressBook] addressBookRef],
                          (CFStringRef)kABPersonRecordType,
                          (CFStringRef)property);
#endif  // GTM_IPHONE_SDK
}
@end

@implementation GTMABGroup

+ (GTMABGroup *)groupNamed:(NSString *)name {
  GTMABGroup *group = [[[self alloc] init] autorelease];
  if (group) {
    if (![group setValue:name forProperty:kABGroupNameProperty]) {
      // COV_NF_START
      // Can't get setValue to fail for me
      group = nil;
      // COV_NF_END
    }
  }
  return group;
}

- (id)init {
  ABRecordRef group = ABGroupCreate();
  self = [super initWithRecord:group];
  if (group) {
    CFRelease(group);
  }
  return self;
}

- (NSArray *)members {
  NSArray *people
    = GTMCFAutorelease(ABGroupCopyArrayOfAllMembers([self recordRef]));
  NSMutableArray *gtmPeople = [NSMutableArray arrayWithCapacity:[people count]];
  id person;
  for (person in people) {
    [gtmPeople addObject:[GTMABPerson recordWithRecord:(ABRecordRef)person]];
  }
  return gtmPeople;
}

- (BOOL)addMember:(GTMABPerson *)person {
#if GTM_IPHONE_SDK
  CFErrorRef cfError = nil;
  // We check for person because of
  // Radar 6202860 Passing nil person into ABGroupAddMember crashes
  bool wasGood = person && ABGroupAddMember([self recordRef],
                                            [person recordRef], &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = person && ABGroupAddMember([self recordRef],
                                            [person recordRef]);
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (BOOL)removeMember:(GTMABPerson *)person {
#if GTM_IPHONE_SDK
  CFErrorRef cfError = nil;
  // We check for person because of
  // Radar 6202860 Passing nil person into ABGroupAddMember crashes
  // (I know this is remove, but it crashes there too)
  bool wasGood = person && ABGroupRemoveMember([self recordRef],
                                               [person recordRef], &cfError);
  if (cfError) {
    // COV_NF_START
    _GTMDevLog(@"Error in [%@ %@]: %@",
               [self class], NSStringFromSelector(_cmd), cfError);
    CFRelease(cfError);
    // COV_NF_END
  }
#else  // GTM_IPHONE_SDK
  bool wasGood = person != nil;
  if (wasGood) {
    NSArray *array = GTMCFAutorelease(ABPersonCopyParentGroups([person recordRef]));
    if ([array containsObject:[self recordRef]]) {
      wasGood = ABGroupRemoveMember([self recordRef],
                                    [person recordRef]);
    } else {
      wasGood = NO;
    }
  }
#endif  // GTM_IPHONE_SDK
  return wasGood ? YES : NO;
}

- (NSString *)compositeName {
#if GTM_IPHONE_SDK
  return GTMCFAutorelease(ABRecordCopyCompositeName([self recordRef]));
#else  // GTM_IPHONE_SDK
  return [self valueForProperty:kGTMABGroupNameProperty];
#endif  // GTM_IPHONE_SDK
}

+ (GTMABPropertyType)typeOfProperty:(GTMABPropertyID)property {
  GTMABPropertyType type = kGTMABInvalidPropertyType;
  if (property == kABGroupNameProperty) {
    type = kGTMABStringPropertyType;
  }
  return type;
}

+ (NSString *)localizedPropertyName:(GTMABPropertyID)property {
  NSString *name = kGTMABUnknownPropertyName;
  if (property == kABGroupNameProperty) {
    name = NSLocalizedStringFromTable(@"Name",
                                      @"GTMABAddressBook",
                                      @"name property");
  }
  return name;
}

- (NSString *)description {
#if GTM_IPHONE_SDK
  return [NSString stringWithFormat:@"%@ %@ %d",
          [self class],
          [self valueForProperty:kABGroupNameProperty],
          [self recordID]];
#else  // GTM_IPHONE_SDK
  return [NSString stringWithFormat:@"%@ %@ %@",
          [self class],
          [self valueForProperty:kABGroupNameProperty],
          [self recordID]];
#endif  // GTM_IPHONE_SDK
}
@end

@implementation GTMABMultiValue
- (id)init {
  // Call super init and release so we don't leak
  [[super init] autorelease];
  [self doesNotRecognizeSelector:_cmd];
  return nil;  // COV_NF_LINE
}

- (id)initWithMultiValue:(ABMultiValueRef)multiValue {
  if ((self = [super init])) {
    if (!multiValue) {
      [self release];
      self = nil;
    } else {
      multiValue_ = CFRetain(multiValue);
    }
  }
  return self;
}

- (id)copyWithZone:(NSZone *)zone {
  return [[GTMABMultiValue alloc] initWithMultiValue:multiValue_];
}

- (id)mutableCopyWithZone:(NSZone *)zone {
  return [[GTMABMutableMultiValue alloc] initWithMultiValue:multiValue_];
}

- (NSUInteger)hash {
  // I'm implementing hash instead of using CFHash(multiValue_) because
  // 6203854 ABMultiValues hash to their address
  NSUInteger count = [self count];
  NSUInteger hash = 0;
  for (NSUInteger i = 0; i < count;  ++i) {
    NSString *label = [self labelAtIndex:i];
    id value = [self valueAtIndex:i];
    hash += [label hash];
    hash += [value hash];
  }
  return hash;
}

- (BOOL)isEqual:(id)object {
  // I'm implementing isEqual instea of using CFEquals(multiValue,...) because
  // 6203854 ABMultiValues hash to their address
  // and it appears CFEquals just calls through to hash to compare them.
  BOOL isEqual = NO;
  if ([object respondsToSelector:@selector(multiValueRef)]) {
    isEqual = multiValue_ == [object multiValueRef];
    if (!isEqual) {
      NSUInteger count = [self count];
      NSUInteger objCount = [(GTMABMultiValue *)object count];
      isEqual = count == objCount;
      for (NSUInteger i = 0; isEqual && i < count;  ++i) {
        NSString *label = [self labelAtIndex:i];
        NSString *objLabel = [object labelAtIndex:i];
        isEqual = [label isEqual:objLabel];
        if (isEqual) {
          id value = [self valueAtIndex:i];
          GTMABMultiValue *multiValueObject
            = GTM_STATIC_CAST(GTMABMultiValue, object);
          id objValue = [multiValueObject valueAtIndex:i];
          isEqual = [value isEqual:objValue];
        }
      }
    }
  }
  return isEqual;
}

- (void)dealloc {
  if (multiValue_) {
    CFRelease(multiValue_);
  }
  [super dealloc];
}

- (ABMultiValueRef)multiValueRef {
  return multiValue_;
}

- (NSUInteger)count {
#if GTM_IPHONE_SDK
  return ABMultiValueGetCount(multiValue_);
#else  // GTM_IPHONE_SDK
  return ABMultiValueCount(multiValue_);
#endif  // GTM_IPHONE_SDK
}

- (id)valueAtIndex:(NSUInteger)idx {
  id value = nil;
  if (idx < [self count]) {
    value = GTMCFAutorelease(ABMultiValueCopyValueAtIndex(multiValue_, idx));
    ABPropertyType type = [self propertyType];
    if (type == kGTMABIntegerPropertyType
        || type == kGTMABRealPropertyType
        || type == kGTMABDictionaryPropertyType) {
      // This is because of
      // 6208390 Integer and real values don't work in ABMultiValueRefs
      // Apparently they forget to add a ref count on int, real and
      // dictionary values in ABMultiValueCopyValueAtIndex, although they do
      // remember them for all other types.
      // Once they fix this, this will lead to a leak, but I figure the leak
      // is better than the crash. Our unittests will test to make sure that
      // this is the case, and once we find a system that has this fixed, we
      // can conditionalize this code. Look for testRadar6208390 in
      // GTMABAddressBookTest.m
      // Also, search for 6208390 below and fix the fast enumerator to actually
      // be somewhat performant when this is fixed.
#ifndef __clang_analyzer__
      [value retain];
#endif  // __clang_analyzer__
    }
  }
  return value;
}

- (NSString *)labelAtIndex:(NSUInteger)idx {
  NSString *label = nil;
  if (idx < [self count]) {
    label = GTMCFAutorelease(ABMultiValueCopyLabelAtIndex(multiValue_, idx));
  }
  return label;
}

- (GTMABMultiValueIdentifier)identifierAtIndex:(NSUInteger)idx {
  GTMABMultiValueIdentifier identifier = kGTMABMultiValueInvalidIdentifier;
  if (idx < [self count]) {
#if GTM_IPHONE_SDK
    identifier = ABMultiValueGetIdentifierAtIndex(multiValue_, idx);
#else  // GTM_IPHONE_SDK
    identifier = GTMCFAutorelease(ABMultiValueCopyIdentifierAtIndex(multiValue_,
                                                                  idx));
#endif  // GTM_IPHONE_SDK
  }
  return identifier;
}

- (NSUInteger)indexForIdentifier:(GTMABMultiValueIdentifier)identifier {
#if GTM_IPHONE_SDK
  NSUInteger idx = ABMultiValueGetIndexForIdentifier(multiValue_, identifier);
#else  // GTM_IPHONE_SDK
  NSUInteger idx = ABMultiValueIndexForIdentifier(multiValue_,
                                                  (CFStringRef)identifier);
#endif  // GTM_IPHONE_SDK
  return idx == (NSUInteger)kCFNotFound ? (NSUInteger)NSNotFound : idx;
}

- (GTMABPropertyType)propertyType {
#if GTM_IPHONE_SDK
  return ABMultiValueGetPropertyType(multiValue_);
#else  // GTM_IPHONE_SDK
  return ABMultiValuePropertyType(multiValue_);
#endif  // GTM_IPHONE_SDK
}

- (id)valueForIdentifier:(GTMABMultiValueIdentifier)identifier {
  return [self valueAtIndex:[self indexForIdentifier:identifier]];
}

- (NSString *)labelForIdentifier:(GTMABMultiValueIdentifier)identifier {
  return [self labelAtIndex:[self indexForIdentifier:identifier]];
}

- (unsigned long*)mutations {
  // We just need some constant non-zero value here so fast enumeration works.
  // Dereferencing self should give us the isa which will stay constant
  // over the enumeration.
  return (unsigned long*)self;
}

- (NSEnumerator *)valueEnumerator {
  return [GTMABMultiValueEnumerator valueEnumeratorFor:self];
}

- (NSEnumerator *)labelEnumerator {
  return [GTMABMultiValueEnumerator labelEnumeratorFor:self];
}

@end

@implementation GTMABMutableMultiValue
+ (id)valueWithPropertyType:(GTMABPropertyType)type {
  return [[[self alloc] initWithPropertyType:type] autorelease];
}

- (id)initWithPropertyType:(GTMABPropertyType)type {
  ABMutableMultiValueRef ref = nil;
  if (type != kGTMABInvalidPropertyType) {
#if GTM_IPHONE_SDK
    ref = ABMultiValueCreateMutable(type);
#else  // GTM_IPHONE_SDK
    ref = ABMultiValueCreateMutable();
#endif  // GTM_IPHONE_SDK
  }
  self = [super initWithMultiValue:ref];
  if (ref) {
    CFRelease(ref);
  }
  return self;
}

- (id)initWithMultiValue:(ABMultiValueRef)multiValue {
  ABMutableMultiValueRef ref = nil;
  if (multiValue) {
    ref = ABMultiValueCreateMutableCopy(multiValue);
  }
  self = [super initWithMultiValue:ref];
  if (ref) {
    CFRelease(ref);
  }
  return self;
}

- (id)initWithMutableMultiValue:(ABMutableMultiValueRef)multiValue {
  return [super initWithMultiValue:multiValue];
}

- (BOOL)checkValueType:(id)value {
  BOOL isGood = NO;
  if (value) {
    TypeClassNameMap singleValueTypeMap[] = {
      { kGTMABStringPropertyType, [NSString class] },
      { kGTMABIntegerPropertyType, [NSNumber class] },
      { kGTMABRealPropertyType, [NSNumber class] },
      { kGTMABDateTimePropertyType, [NSDate class] },
      { kGTMABDictionaryPropertyType, [NSDictionary class] },
    };
    GTMABPropertyType type = [self propertyType] & ~kABMultiValueMask;
#if GTM_MACOS_SDK
    // Since on the desktop mutables don't have a type UNTIL they have
    // something in them, return YES if it's empty.
    if ((type == 0) && ([self count] == 0)) return YES;
#endif  // GTM_MACOS_SDK
    for (size_t i = 0;
         i < sizeof(singleValueTypeMap) / sizeof(TypeClassNameMap); ++i) {
      if (singleValueTypeMap[i].pType == type) {
        if ([[value class] isSubclassOfClass:singleValueTypeMap[i].class]) {
          isGood = YES;
          break;
        }
      }
    }
  }
  return isGood;
}

- (GTMABMultiValueIdentifier)addValue:(id)value withLabel:(CFStringRef)label {
  GTMABMultiValueIdentifier identifier = kGTMABMultiValueInvalidIdentifier;
  // We check label and value here because of
  // radar 6202827  Passing nil info ABMultiValueAddValueAndLabel causes crash
  bool wasGood = label && [self checkValueType:value];
  if (wasGood) {
#if GTM_IPHONE_SDK
    wasGood = ABMultiValueAddValueAndLabel(multiValue_,
                                           value,
                                           label,
                                           &identifier);
#else  // GTM_IPHONE_SDK
    wasGood = ABMultiValueAdd((ABMutableMultiValueRef)multiValue_,
                              value,
                              label,
                              (CFStringRef *)&identifier);
#endif  // GTM_IPHONE_SDK
  }
  if (!wasGood) {
    identifier = kGTMABMultiValueInvalidIdentifier;
  } else {
    mutations_++;
  }
  return identifier;
}

- (GTMABMultiValueIdentifier)insertValue:(id)value
                               withLabel:(CFStringRef)label
                                 atIndex:(NSUInteger)idx {
  GTMABMultiValueIdentifier identifier = kGTMABMultiValueInvalidIdentifier;
  // We perform a check here to ensure that we don't get bitten by
  // Radar 6202807 ABMultiValueInsertValueAndLabelAtIndex allows you to insert
  //               values past end
  NSUInteger count = [self count];
  // We check label and value here because of
  // radar 6202827  Passing nil info ABMultiValueAddValueAndLabel causes crash
  bool wasGood = idx <= count && label && [self checkValueType:value];
  if (wasGood) {
#if GTM_IPHONE_SDK
    wasGood = ABMultiValueInsertValueAndLabelAtIndex(multiValue_,
                                                     value,
                                                     label,
                                                     idx,
                                                     &identifier);
#else  // GTM_IPHONE_SDK
    wasGood = ABMultiValueInsert((ABMutableMultiValueRef)multiValue_,
                                 value,
                                 label,
                                 idx,
                                 (CFStringRef *)&identifier);
#endif  // GTM_IPHONE_SDK
  }
  if (!wasGood) {
    identifier = kGTMABMultiValueInvalidIdentifier;
  } else {
    mutations_++;
  }
  return identifier;
}

- (BOOL)removeValueAndLabelAtIndex:(NSUInteger)idx {
  BOOL isGood = NO;
  NSUInteger count = [self count];
  if (idx < count) {
#if GTM_IPHONE_SDK
    bool wasGood = ABMultiValueRemoveValueAndLabelAtIndex(multiValue_,
                                                          idx);
#else  // GTM_IPHONE_SDK
    bool wasGood = ABMultiValueRemove((ABMutableMultiValueRef)multiValue_,
                                      idx);
#endif  // GTM_IPHONE_SDK
    if (wasGood) {
      mutations_++;
      isGood = YES;
    }
  }
  return isGood;
}

- (BOOL)replaceValueAtIndex:(NSUInteger)idx withValue:(id)value {
  BOOL isGood = NO;
  NSUInteger count = [self count];
  if (idx < count && [self checkValueType:value]) {
#if GTM_IPHONE_SDK
    bool goodReplace = ABMultiValueReplaceValueAtIndex(multiValue_,
                                                       value, idx);
#else  // GTM_IPHONE_SDK
    bool goodReplace
      = ABMultiValueReplaceValue((ABMutableMultiValueRef)multiValue_,
                                 (CFTypeRef)value, idx);
#endif  // GTM_IPHONE_SDK
    if (goodReplace) {
      mutations_++;
      isGood = YES;
    }
  }
  return isGood;
}

- (BOOL)replaceLabelAtIndex:(NSUInteger)idx withLabel:(CFStringRef)label {
  BOOL isGood = NO;
  NSUInteger count = [self count];
  if (idx < count) {
#if GTM_IPHONE_SDK
    bool goodReplace = ABMultiValueReplaceLabelAtIndex(multiValue_,
                                                       label, idx);
#else  // GTM_IPHONE_SDK
    bool goodReplace
      = ABMultiValueReplaceLabel((ABMutableMultiValueRef)multiValue_,
                                 (CFTypeRef)label, idx);
#endif  // GTM_IPHONE_SDK
    if (goodReplace) {
      mutations_++;
      isGood = YES;
    }
  }
  return isGood;
}

- (unsigned long*)mutations {
  return &mutations_;
}
@end


@implementation GTMABMultiValueEnumerator

+ (id)valueEnumeratorFor:(GTMABMultiValue*)enumeree {
  return [[[self alloc] initWithEnumeree:enumeree useLabels:NO] autorelease];
}

+ (id)labelEnumeratorFor:(GTMABMultiValue*)enumeree  {
  return [[[self alloc] initWithEnumeree:enumeree useLabels:YES] autorelease];
}

- (id)initWithEnumeree:(GTMABMultiValue*)enumeree useLabels:(BOOL)useLabels {
  if ((self = [super init])) {
    if (enumeree) {
      enumeree_ = [enumeree retain];
      useLabels_ = useLabels;
    } else {
      // COV_NF_START
      // Since this is a private class where the enumeree creates us
      // there is no way we should ever get here.
      [self release];
      self = nil;
      // COV_NF_END
    }
  }
  return self;
}

- (void)dealloc {
  [enumeree_ release];
  [super dealloc];
}

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state
                                  objects:(id *)stackbuf
                                    count:(NSUInteger)len {
  NSUInteger i;
  if (!ref_) {
    count_ = [enumeree_ count];
    ref_ = [enumeree_ multiValueRef];
  }

  for (i = 0; state->state < count_ && i < len; ++i, ++state->state) {
    if (useLabels_) {
      stackbuf[i] = GTMCFAutorelease(ABMultiValueCopyLabelAtIndex(ref_,
                                                                  state->state));
    } else {
      // TODO(dmaclach) Check this on Mac Desktop and use fast path if we can
      // Yes this is slow, but necessary in light of radar 6208390
      // Once this is fixed we can go to something similar to the label
      // case which should speed stuff up again. Hopefully anybody who wants
      // real performance is willing to move down to the C API anyways.
      stackbuf[i] = [enumeree_ valueAtIndex:state->state];
    }
  }

  state->itemsPtr = stackbuf;
  state->mutationsPtr = [enumeree_ mutations];
  return i;
}

- (id)nextObject {
  id value = nil;
  if (!ref_) {
    count_ = [enumeree_ count];
    mutations_ = *[enumeree_ mutations];
    ref_ = [enumeree_ multiValueRef];

  }
  if (mutations_ != *[enumeree_ mutations]) {
    NSString *reason = [NSString stringWithFormat:@"*** Collection <%@> was "
                        "mutated while being enumerated", enumeree_];
    [[NSException exceptionWithName:NSGenericException
                             reason:reason
                           userInfo:nil] raise];
  }
  if (index_ < count_) {
    if (useLabels_) {
      value = GTMCFAutorelease(ABMultiValueCopyLabelAtIndex(ref_,
                                                            index_));
    } else {
      // TODO(dmaclach) Check this on Mac Desktop and use fast path if we can
      // Yes this is slow, but necessary in light of radar 6208390
      // Once this is fixed we can go to something similar to the label
      // case which should speed stuff up again. Hopefully anybody who wants
      // real performance is willing to move down to the C API anyways.
      value = [enumeree_ valueAtIndex:index_];
    }
    index_ += 1;
  }
  return value;
}
@end