#import "GTReference.h"

#import "GTOID.h"

#import "GTReflog+Private.h"

#import "GTRepository+Private.h"

#import "GTRepository.h"

#import "GTSignature.h"

#import "NSError+Git.h"

#import "NSString+Git.h"

#import "GTRepository+References.h"

#import "git2/errors.h"

@interface GTReference ()

@property (nonatomic, readonly, assign) git_reference *git_reference;

static NSString *referenceTypeToString(GTReferenceType type) {

switch (type) {

case GTReferenceTypeInvalid:

return @"invalid";

case GTReferenceTypeDirect:

return @"direct";

case GTReferenceTypeSymbolic:

return @"symbolic";

}

return @"unknown";

}

@implementation GTReference

- (void)dealloc {

if (_git_reference != NULL) {

git_reference_free(_git_reference);

_git_reference = NULL;

}

}

#pragma mark API

- (BOOL)isRemote {

return git_reference_is_remote(self.git_reference) != 0;

}

+ (instancetype)referenceByResolvingSymbolicReference:(GTReference *)symbolicRef error:(NSError **)error {

return [[self alloc] initByResolvingSymbolicReference:symbolicRef error:error];

}

- (instancetype)init {

NSAssert(NO, @"Call to an unavailable initializer.");

return nil;

}

- (instancetype)initByResolvingSymbolicReference:(GTReference *)symbolicRef error:(NSError **)error {

NSParameterAssert(symbolicRef != nil);

git_reference *ref = NULL;

int gitError = git_reference_resolve(&ref, symbolicRef.git_reference);

if (gitError != GIT_OK) {

if (error != NULL) *error = [NSError git_errorFor:gitError description:@"Failed to resolve reference %@.", symbolicRef.name];

return nil;

}

return [self initWithGitReference:ref repository:symbolicRef.repository];

}

- (instancetype)initWithGitReference:(git_reference *)ref repository:(GTRepository *)repo {

NSParameterAssert(ref != NULL);

NSParameterAssert(repo != nil);

self = [super init];

if (self == nil) return nil;

_git_reference = ref;

_repository = repo;

return self;

}

- (BOOL)isBranch {

return git_reference_is_branch(self.git_reference) != 0;

}

- (BOOL)isTag {

return git_reference_is_tag(self.git_reference) != 0;

}

- (BOOL)isNote {

return git_reference_is_note(self.git_reference) != 0;

}

- (NSString *)name {

const char *cRefName = git_reference_name(self.git_reference);

NSAssert(cRefName != nil, @"Unexpected nil name");

NSString *refName = @(cRefName);

NSAssert(refName, @"refname is nil");

return refName;

}

- (GTReference *)referenceByRenaming:(NSString *)newName error:(NSError **)error {

NSParameterAssert(newName != nil);

git_reference *newRef = NULL;

int gitError = git_reference_rename(&newRef, self.git_reference, newName.UTF8String, 0, NULL);

if (gitError != GIT_OK) {

if (error != NULL) *error = [NSError git_errorFor:gitError description:@"Failed to rename reference %@ to %@.", self.name, newName];

return nil;

}

return [[self.class alloc] initWithGitReference:newRef repository:self.repository];

}

- (GTReferenceType)referenceType {

return (GTReferenceType)git_reference_type(self.git_reference);

}

- (id)unresolvedTarget {

if (self.referenceType == GTReferenceTypeDirect) {

const git_oid *oid = git_reference_target(self.git_reference);

if (oid == NULL) return nil;

return [self.repository lookUpObjectByGitOid:oid error:NULL];

} else if (self.referenceType == GTReferenceTypeSymbolic) {

NSString *refName = @(git_reference_symbolic_target(self.git_reference));

if (refName == NULL) return nil;

return [self.repository lookUpReferenceWithName:refName error:NULL];

}

return nil;

}

- (id)resolvedTarget {

git_object *obj;

if (git_reference_peel(&obj, self.git_reference, GIT_OBJECT_ANY) != GIT_OK) {

return nil;

}

return [GTObject objectWithObj:obj inRepository:self.repository];

}

- (GTReference *)resolvedReference {

GTReference *resolvedReference = [self.class referenceByResolvingSymbolicReference:self error:NULL];

return resolvedReference ? resolvedReference : self;

}

- (GTOID *)targetOID {

return [self.resolvedTarget OID];

}

- (GTReference *)referenceByUpdatingTarget:(NSString *)newTarget message:(NSString *)message error:(NSError **)error {

NSParameterAssert(newTarget != nil);

int gitError;

git_reference *newRef = NULL;

if (git_reference_type(self.git_reference) == GIT_REFERENCE_DIRECT) {

GTOID *oid = [[GTOID alloc] initWithSHA:newTarget error:error];

if (oid == nil) return nil;

gitError = git_reference_set_target(&newRef, self.git_reference, oid.git_oid, message.UTF8String);

} else {

gitError = git_reference_symbolic_set_target(&newRef, self.git_reference, newTarget.UTF8String, message.UTF8String);

}

if (gitError != GIT_OK) {

if (error != NULL) *error = [NSError git_errorFor:gitError description:@"Failed to update reference %@ to target %@.", self.name, newTarget];

return nil;

}

return [[self.class alloc] initWithGitReference:newRef repository:self.repository];

}

- (BOOL)deleteWithError:(NSError **)error {

int gitError = git_reference_delete(self.git_reference);

if (gitError != GIT_OK) {

if (error != NULL) *error = [NSError git_errorFor:gitError description:@"Failed to delete reference %@.", self.name];

return NO;

}

return YES;

}

- (GTReference *)resolvedReferenceWithError:(NSError **)error {

return [GTReference referenceByResolvingSymbolicReference:self error:error];

}

- (const git_oid *)git_oid {

return git_reference_target(self.git_reference);

}

- (GTOID *)OID {

const git_oid *oid = self.git_oid;

if (oid == NULL) return nil;

return [[GTOID alloc] initWithGitOid:oid];

}

- (GTReference *)reloadedReferenceWithError:(NSError **)error {

return [self.repository lookUpReferenceWithName:self.name error:error];

}

+ (NSError *)invalidReferenceError {

return [NSError git_errorFor:GTReferenceErrorCodeInvalidReference description:@"Invalid git_reference."];

}

- (GTReflog *)reflog {

return [[GTReflog alloc] initWithReference:self];

}

+ (BOOL)isValidReferenceName:(NSString *)refName {

return git_reference_is_valid_name(refName.UTF8String) == 1;

}

#pragma mark NSObject

- (NSString *)description {

return [NSString stringWithFormat:@"<%@: %p>{ OID: %@, type: %@, remote: %i }", self.class, self, self.OID, referenceTypeToString(self.referenceType), (int)self.remote];

}

- (NSUInteger)hash {

return self.name.hash;

}

- (BOOL)isEqual:(GTReference *)reference {

if (self == reference) return YES;

if (![reference isKindOfClass:GTReference.class]) return NO;

return [self.name isEqual:reference.name] && [self.unresolvedTarget isEqual:reference.unresolvedTarget];

}