// This source code is dual-licensed under the Mozilla Public License ("MPL"),
// version 1.1 and the Apache License ("ASL"), version 2.0.
//
// The ASL v2.0:
//
// ---------------------------------------------------------------------------
// Copyright 2016 Pivotal Software, 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.
// ---------------------------------------------------------------------------
//
// The MPL v1.1:
//
// ---------------------------------------------------------------------------
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// https://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
// License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is RabbitMQ
//
// The Initial Developer of the Original Code is Pivotal Software, Inc.
// All Rights Reserved.
//
// Alternatively, the contents of this file may be used under the terms
// of the Apache Standard license (the "ASL License"), in which case the
// provisions of the ASL License are applicable instead of those
// above. If you wish to allow use of your version of this file only
// under the terms of the ASL License and not to allow others to use
// your version of this file under the MPL, indicate your decision by
// deleting the provisions above and replace them with the notice and
// other provisions required by the ASL License. If you do not delete
// the provisions above, a recipient may use your version of this file
// under either the MPL or the ASL License.
// ---------------------------------------------------------------------------

#import "RMQParser.h"
#import "RMQTable.h"

// from https://www.rabbitmq.com/amqp-0-9-1-errata.html
// but without anything the Java client doesn't implement
typedef NS_ENUM(char, RMQParserFieldValue) {
    RMQParserBoolean       = 't',
    RMQParserSigned8Bit    = 'b',
    RMQParserSigned16Bit   = 's',
    RMQParserUnsigned16Bit = 'u',
    RMQParserSigned32Bit   = 'I',
    RMQParserUnsigned32Bit = 'i',
    RMQParserSigned64Bit   = 'l',
    RMQParser32BitFloat    = 'f',
    RMQParser64BitFloat    = 'd',
    RMQParserDecimal       = 'D',
    RMQParserLongString    = 'S',
    RMQParserArray         = 'A',
    RMQParserTimestamp     = 'T',
    RMQParserNestedTable   = 'F',
    RMQParserVoid          = 'V',
    RMQParserByteArray     = 'x',
};

@interface RMQValueForUnsupportedField : RMQValue <RMQFieldValue>
@end

@implementation RMQValueForUnsupportedField
- (NSData *)amqFieldValueType {
    return nil;
}
- (NSData *)amqEncoded {
    return [NSData data];
}
@end

@interface RMQParser ()
@property (nonatomic, readwrite) const char *cursor;
@property (nonatomic, readwrite) const char *end;
@property (nonatomic, readwrite) NSData *data;
@end

@implementation RMQParser

- (instancetype)initWithData:(NSData *)data {
    self = [super init];
    if (self) {
        self.data   = data;
        self.cursor = (const char *)data.bytes;
        self.end    = (const char *)data.bytes + data.length;
    }
    return self;
}

- (NSDictionary<NSString *, RMQValue<RMQFieldValue> *> *)parseFieldTable {
    NSMutableDictionary *dict = [NSMutableDictionary new];
    const char *start = self.cursor;

    UInt32 length = [self parseLongUInt];

    while (self.cursor < start + length && self.cursor < self.end) {
        NSString *key = [self parseShortString];

        RMQParserFieldValue type = *(self.cursor++);
        RMQValue<RMQFieldValue> *value = [self parseValueForType:type];

        if ([value isKindOfClass:[RMQValueForUnsupportedField class]]) {
            return @{};
        }
        dict[key] = value;
    }

    return dict;
}

- (char)parseOctet {
    if (self.cursor + 1 > self.end) {
        return 0;
    } else {
        return *((self.cursor)++);
    }
}

- (UInt32)parseLongUInt {
    UInt32 value;
    value = CFSwapInt32BigToHost(*(UInt32 *)self.cursor);
    if (self.cursor + sizeof(value) > self.end) {
        return 0;
    } else {
        self.cursor += sizeof(value);
        return value;
    }
}

- (UInt64)parseLongLongUInt {
    UInt64 value;
    value = CFSwapInt64BigToHost(*(UInt64 *)self.cursor);
    if (self.cursor + sizeof(value) > self.end) {
        return 0;
    } else {
        self.cursor += sizeof(value);
        return value;
    }
}

- (NSDate *)parseTimestamp {
    NSTimeInterval interval = [self parseLongLongUInt];
    return [NSDate dateWithTimeIntervalSince1970:interval];
}

- (UInt16)parseShortUInt {
    UInt16 value;
    value = CFSwapInt16BigToHost(*(UInt16 *)self.cursor);
    if (self.cursor + sizeof(value) > self.end) {
        return 0;
    } else {
        self.cursor += sizeof(value);
        return value;
    }
}

- (BOOL)parseBoolean {
    return [self parseOctet] != 0;
}

- (NSString *)parseShortString {
    UInt8 length = *self.cursor;
    const char *expectedStringEnd = self.cursor + sizeof(length) + length;

    if (expectedStringEnd > self.end) {
        return @"";
    } else {
        self.cursor++;
        NSString *string = [NSString stringWithFormat:@"%.*s", length, self.cursor];
        self.cursor += length;

        return string;
    }
}

- (NSString *)parseLongString {
    if (self.cursor >= self.end) {
        return @"";
    }
    UInt32 length = CFSwapInt32BigToHost(*(UInt32 *)self.cursor);
    const char *expectedStringEnd = self.cursor + sizeof(length) + length;

    if (expectedStringEnd > self.end) {
        return @"";
    } else {
        self.cursor += sizeof(length);
        int readCharsLength = length;
        NSString *string = [NSString stringWithFormat:@"%.*s", readCharsLength, self.cursor];
        self.cursor += length;

        return string;
    }
}

- (NSData *)parseLength:(UInt32)length {
    return [NSData dataWithBytes:(void *)self.cursor length:length];
}

# pragma mark - Private

- (NSArray *)parseFieldArray {
    NSMutableArray *array = [NSMutableArray new];
    const char *start      = self.cursor;
    int32_t length         = [self parseLongInt];
    const char *endOfArray = start + sizeof(length) + length;

    while (self.cursor < endOfArray && self.cursor < self.end) {
        RMQParserFieldValue type = *(self.cursor++);
        [array addObject:[self parseValueForType:type]];
    }

    return array;
}

- (RMQValue<RMQFieldValue> *)parseValueForType:(RMQParserFieldValue)type {
    switch (type) {
        case RMQParserBoolean:
            return [[RMQBoolean alloc] init:[self parseBoolean]];
        case RMQParserSigned8Bit:
            return [[RMQSignedByte alloc] init:[self parseSignedByte]];
        case RMQParserSigned16Bit:
            return [[RMQSignedShort alloc] init:[self parseShortInt]];
        case RMQParserUnsigned16Bit:
            return [[RMQShort alloc] init:[self parseShortUInt]];
        case RMQParserSigned32Bit:
            return [[RMQSignedLong alloc] init:[self parseLongInt]];
        case RMQParserUnsigned32Bit:
            return [[RMQLong alloc] init:[self parseLongUInt]];
        case RMQParserSigned64Bit:
            return [[RMQSignedLonglong alloc] init:[self parseLongLongInt]];
        case RMQParser32BitFloat:
            return [[RMQFloat alloc] init:[self parseFloat]];
        case RMQParser64BitFloat:
            return [[RMQDouble alloc] init:[self parseDouble]];
        case RMQParserDecimal:
            [self parseDecimal];
            return [RMQDecimal new];
        case RMQParserLongString:
            return [[RMQLongstr alloc] init:[self parseLongString]];
        case RMQParserArray:
            return [[RMQArray alloc] init:[self parseFieldArray]];
        case RMQParserTimestamp:
            return [[RMQTimestamp alloc] init:[self parseTimestamp]];
        case RMQParserNestedTable:
            return [[RMQTable alloc] init:[self parseFieldTable]];
        case RMQParserVoid:
            return [RMQVoid new];
        case RMQParserByteArray:
            return [[RMQByteArray alloc] init:[self parseByteArray]];
        default:
            return [RMQValueForUnsupportedField new];
    }
}

- (int32_t)parseLongInt {
    int32_t value;
    value = CFSwapInt32BigToHost(*(int32_t *)self.cursor);
    self.cursor += sizeof(value);

    return value;
}

- (int64_t)parseLongLongInt {
    int64_t value;
    value = CFSwapInt64BigToHost(*(int64_t *)self.cursor);
    self.cursor += sizeof(value);

    return value;
}

- (float)parseFloat {
    float value;
    value = CFConvertFloatSwappedToHost(*(CFSwappedFloat32 *)self.cursor);
    self.cursor += sizeof(value);

    return value;
}

- (double)parseDouble {
    double value;
    value = CFConvertDoubleSwappedToHost(*(CFSwappedFloat64 *)self.cursor);
    self.cursor += sizeof(value);

    return value;
}

- (void)parseDecimal {
    [self parseOctet];
    [self parseLongInt];
}

- (int16_t)parseShortInt {
    int16_t value;
    value = CFSwapInt16BigToHost(*(int16_t *)self.cursor);
    self.cursor += sizeof(value);

    return value;
}

- (signed char)parseSignedByte {
    return *((self.cursor)++);
}

- (NSData *)parseByteArray {
    UInt32 length = [self parseLongUInt];
    NSData *data = [self parseLength:length];
    self.cursor += length;
    return data;
}

@end