/*
 * Copyright 2012 ZXing authors
 *
 * 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 "ZXBitSource.h"
#import "ZXCharacterSetECI.h"
#import "ZXDecoderResult.h"
#import "ZXErrors.h"
#import "ZXErrorCorrectionLevel.h"
#import "ZXMode.h"
#import "ZXQRCodeDecodedBitStreamParser.h"
#import "ZXQRCodeVersion.h"
#import "ZXStringUtils.h"


/**
 * See ISO 18004:2006, 6.4.4 Table 5
 */
char const ALPHANUMERIC_CHARS[45] = {
  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
  'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
  'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  ' ', '$', '%', '*', '+', '-', '.', '/', ':'
};

int const GB2312_SUBSET = 1;

@interface ZXQRCodeDecodedBitStreamParser ()

+ (BOOL)decodeHanziSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
+ (BOOL)decodeKanjiSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
+ (BOOL)decodeByteSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count currentCharacterSetECI:(ZXCharacterSetECI *)currentCharacterSetECI byteSegments:(NSMutableArray *)byteSegments hints:(ZXDecodeHints *)hints;
+ (BOOL)decodeAlphanumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count fc1InEffect:(BOOL)fc1InEffect;
+ (BOOL)decodeNumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
+ (int)parseECIValue:(ZXBitSource *)bits;

@end

@implementation ZXQRCodeDecodedBitStreamParser

+ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length version:(ZXQRCodeVersion *)version
                    ecLevel:(ZXErrorCorrectionLevel *)ecLevel hints:(ZXDecodeHints *)hints error:(NSError **)error {
  ZXBitSource *bits = [[[ZXBitSource alloc] initWithBytes:bytes length:length] autorelease];
  NSMutableString *result = [NSMutableString stringWithCapacity:50];
  ZXCharacterSetECI *currentCharacterSetECI = nil;
  BOOL fc1InEffect = NO;
  NSMutableArray *byteSegments = [NSMutableArray arrayWithCapacity:1];
  ZXMode *mode;

  do {
    if ([bits available] < 4) {
      mode = [ZXMode terminatorMode];
    } else {
      mode = [ZXMode forBits:[bits readBits:4]];
      if (!mode) {
        if (error) *error = FormatErrorInstance();
        return nil;
      }
    }
    if (![mode isEqual:[ZXMode terminatorMode]]) {
      if ([mode isEqual:[ZXMode fnc1FirstPositionMode]] || [mode isEqual:[ZXMode fnc1SecondPositionMode]]) {
        fc1InEffect = YES;
      } else if ([mode isEqual:[ZXMode structuredAppendMode]]) {
        if (bits.available < 16) {
          if (error) *error = FormatErrorInstance();
          return nil;
        }
        [bits readBits:16];
      } else if ([mode isEqual:[ZXMode eciMode]]) {
        int value = [self parseECIValue:bits];
        currentCharacterSetECI = [ZXCharacterSetECI characterSetECIByValue:value];
        if (currentCharacterSetECI == nil) {
          if (error) *error = FormatErrorInstance();
          return nil;
        }
      } else {
        if ([mode isEqual:[ZXMode hanziMode]]) {
          int subset = [bits readBits:4];
          int countHanzi = [bits readBits:[mode characterCountBits:version]];
          if (subset == GB2312_SUBSET) {
            if (![self decodeHanziSegment:bits result:result count:countHanzi]) {
              if (error) *error = FormatErrorInstance();
              return nil;
            }
          }
        } else {
          int count = [bits readBits:[mode characterCountBits:version]];
          if ([mode isEqual:[ZXMode numericMode]]) {
            if (![self decodeNumericSegment:bits result:result count:count]) {
              if (error) *error = FormatErrorInstance();
              return nil;
            }
          } else if ([mode isEqual:[ZXMode alphanumericMode]]) {
            if (![self decodeAlphanumericSegment:bits result:result count:count fc1InEffect:fc1InEffect]) {
              if (error) *error = FormatErrorInstance();
              return nil;
            }
          } else if ([mode isEqual:[ZXMode byteMode]]) {
            if (![self decodeByteSegment:bits result:result count:count currentCharacterSetECI:currentCharacterSetECI byteSegments:byteSegments hints:hints]) {
              if (error) *error = FormatErrorInstance();
              return nil;
            }
          } else if ([mode isEqual:[ZXMode kanjiMode]]) {
            if (![self decodeKanjiSegment:bits result:result count:count]) {
              if (error) *error = FormatErrorInstance();
              return nil;
            }
          } else {
            if (error) *error = FormatErrorInstance();
            return nil;
          }
        }
      }
    }
  } while (![mode isEqual:[ZXMode terminatorMode]]);
  return [[[ZXDecoderResult alloc] initWithRawBytes:bytes
                                             length:length
                                               text:result.description
                                       byteSegments:byteSegments.count == 0 ? nil : byteSegments
                                            ecLevel:ecLevel == nil ? nil : ecLevel.description] autorelease];
}


/**
 * See specification GBT 18284-2000
 */
+ (BOOL)decodeHanziSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
  if (count * 13 > bits.available) {
    return NO;
  }

  NSMutableData *buffer = [NSMutableData dataWithCapacity:2 * count];
  while (count > 0) {
    int twoBytes = [bits readBits:13];
    int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
    if (assembledTwoBytes < 0x003BF) {
      assembledTwoBytes += 0x0A1A1;
    } else {
      assembledTwoBytes += 0x0A6A1;
    }
    char bytes[2];
    bytes[0] = (char)((assembledTwoBytes >> 8) & 0xFF);
    bytes[1] = (char)(assembledTwoBytes & 0xFF);

    [buffer appendBytes:bytes length:2];

    count--;
  }

  NSString *string = [[[NSString alloc] initWithData:buffer encoding:CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingGB_18030_2000)] autorelease];
  if (string) {
    [result appendString:string];
  }
  return YES;
}

+ (BOOL)decodeKanjiSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
  if (count * 13 > bits.available) {
    return NO;
  }

  NSMutableData *buffer = [NSMutableData dataWithCapacity:2 * count];
  while (count > 0) {
    int twoBytes = [bits readBits:13];
    int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
    if (assembledTwoBytes < 0x01F00) {
      assembledTwoBytes += 0x08140;
    } else {
      assembledTwoBytes += 0x0C140;
    }
    char bytes[2];
    bytes[0] = (char)(assembledTwoBytes >> 8);
    bytes[1] = (char)assembledTwoBytes;
    
    [buffer appendBytes:bytes length:2];

    count--;
  }

  NSString *string = [[[NSString alloc] initWithData:buffer encoding:NSShiftJISStringEncoding] autorelease];
  if (string) {
    [result appendString:string];
  }
  return YES;
}

+ (BOOL)decodeByteSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count currentCharacterSetECI:(ZXCharacterSetECI *)currentCharacterSetECI byteSegments:(NSMutableArray *)byteSegments hints:(ZXDecodeHints *)hints {
  if (count << 3 > bits.available) {
    return NO;
  }
  unsigned char readBytes[count];
  NSMutableArray *readBytesArray = [NSMutableArray arrayWithCapacity:count];

  for (int i = 0; i < count; i++) {
    readBytes[i] = (char)[bits readBits:8];
    [readBytesArray addObject:[NSNumber numberWithChar:readBytes[i]]];
  }

  NSStringEncoding encoding;
  if (currentCharacterSetECI == nil) {
    encoding = [ZXStringUtils guessEncoding:readBytes length:count hints:hints];
  } else {
    encoding = [currentCharacterSetECI encoding];
  }

  NSString *string = [[[NSString alloc] initWithBytes:readBytes length:count encoding:encoding] autorelease];
  if (string) {
    [result appendString:string];
  }
  
  [byteSegments addObject:readBytesArray];
  return YES;
}

+ (unichar)toAlphaNumericChar:(int)value {
  if (value >= 45) {
    return -1;
  }
  return ALPHANUMERIC_CHARS[value];
}

+ (BOOL)decodeAlphanumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count fc1InEffect:(BOOL)fc1InEffect {
  int start = result.length;

  while (count > 1) {
    if ([bits available] < 11) {
      return NO;
    }
    int nextTwoCharsBits = [bits readBits:11];
    unichar next1 = [self toAlphaNumericChar:nextTwoCharsBits / 45];
    unichar next2 = [self toAlphaNumericChar:nextTwoCharsBits % 45];
    if (next1 == -1 || next2 == -1) {
      return NO;
    }
    
    [result appendFormat:@"%C%C", next1, next2];
    count -= 2;
  }

  if (count == 1) {
    if ([bits available] < 6) {
      return NO;
    }
    unichar next1 = [self toAlphaNumericChar:[bits readBits:6]];
    if (next1 == -1) {
      return NO;
    }
    [result appendFormat:@"%C", next1];
  }
  if (fc1InEffect) {
    for (int i = start; i < [result length]; i++) {
      if ([result characterAtIndex:i] == '%') {
        if (i < [result length] - 1 && [result characterAtIndex:i + 1] == '%') {
          [result deleteCharactersInRange:NSMakeRange(i + 1, 1)];
        } else {
          [result insertString:[NSString stringWithFormat:@"%C", (unichar)0x1D]
                       atIndex:i];
        }
      }
    }
  }
  return YES;
}

+ (BOOL)decodeNumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
  // Read three digits at a time
  while (count >= 3) {
    // Each 10 bits encodes three digits
    if (bits.available < 10) {
      return NO;
    }
    int threeDigitsBits = [bits readBits:10];
    if (threeDigitsBits >= 1000) {
      return NO;
    }
    unichar next1 = [self toAlphaNumericChar:threeDigitsBits / 100];
    unichar next2 = [self toAlphaNumericChar:(threeDigitsBits / 10) % 10];
    unichar next3 = [self toAlphaNumericChar:threeDigitsBits % 10];
    if (next1 == -1 || next2 == -1 || next3 == -1) {
      return NO;
    }

    [result appendFormat:@"%C%C%C", next1, next2, next3];
    count -= 3;
  }

  if (count == 2) {
    // Two digits left over to read, encoded in 7 bits
    if (bits.available < 7) {
      return NO;
    }
    int twoDigitsBits = [bits readBits:7];
    if (twoDigitsBits >= 100) {
      return NO;
    }
    unichar next1 = [self toAlphaNumericChar:twoDigitsBits / 10];
    unichar next2 = [self toAlphaNumericChar:twoDigitsBits % 10];
    [result appendFormat:@"%C%C", next1, next2];
  } else if (count == 1) {
    // One digit left over to read
    if (bits.available < 4) {
      return NO;
    }
    int digitBits = [bits readBits:4];
    if (digitBits >= 10) {
      return NO;
    }
    unichar next1 = [self toAlphaNumericChar:digitBits];
    if (next1 == -1) {
      return NO;
    }
    [result appendFormat:@"%C", next1];
  }
  return YES;
}

+ (int)parseECIValue:(ZXBitSource *)bits {
  int firstByte = [bits readBits:8];
  if ((firstByte & 0x80) == 0) {
    return firstByte & 0x7F;
  }
  if ((firstByte & 0xC0) == 0x80) {
    int secondByte = [bits readBits:8];
    return ((firstByte & 0x3F) << 8) | secondByte;
  }
  if ((firstByte & 0xE0) == 0xC0) {
    int secondThirdBytes = [bits readBits:16];
    return ((firstByte & 0x1F) << 16) | secondThirdBytes;
  }
  return -1;
}

@end
