/*
 * 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 "ZXBitMatrix.h"
#import "ZXByteArray.h"
#import "ZXErrors.h"
#import "ZXQRCodeBitMatrixParser.h"
#import "ZXQRCodeDataMask.h"
#import "ZXQRCodeFormatInformation.h"
#import "ZXQRCodeVersion.h"

@interface ZXQRCodeBitMatrixParser ()

@property (nonatomic, strong, readonly) ZXBitMatrix *bitMatrix;
@property (nonatomic, assign) BOOL shouldMirror;
@property (nonatomic, strong) ZXQRCodeFormatInformation *parsedFormatInfo;
@property (nonatomic, strong) ZXQRCodeVersion *parsedVersion;

@end

@implementation ZXQRCodeBitMatrixParser

- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix error:(NSError **)error {
  int dimension = bitMatrix.height;
  if (dimension < 21 || (dimension & 0x03) != 1) {
    if (error) *error = ZXFormatErrorInstance();
    return nil;
  }

  if (self = [super init]) {
    _bitMatrix = bitMatrix;
    _parsedFormatInfo = nil;
    _parsedVersion = nil;
  }
  return self;
}

- (ZXQRCodeFormatInformation *)readFormatInformationWithError:(NSError **)error {
  if (self.parsedFormatInfo != nil) {
    return self.parsedFormatInfo;
  }
  int formatInfoBits1 = 0;

  for (int i = 0; i < 6; i++) {
    formatInfoBits1 = [self copyBit:i j:8 versionBits:formatInfoBits1];
  }

  formatInfoBits1 = [self copyBit:7 j:8 versionBits:formatInfoBits1];
  formatInfoBits1 = [self copyBit:8 j:8 versionBits:formatInfoBits1];
  formatInfoBits1 = [self copyBit:8 j:7 versionBits:formatInfoBits1];

  for (int j = 5; j >= 0; j--) {
    formatInfoBits1 = [self copyBit:8 j:j versionBits:formatInfoBits1];
  }

  int dimension = self.bitMatrix.height;
  int formatInfoBits2 = 0;
  int jMin = dimension - 7;

  for (int j = dimension - 1; j >= jMin; j--) {
    formatInfoBits2 = [self copyBit:8 j:j versionBits:formatInfoBits2];
  }

  for (int i = dimension - 8; i < dimension; i++) {
    formatInfoBits2 = [self copyBit:i j:8 versionBits:formatInfoBits2];
  }

  self.parsedFormatInfo = [ZXQRCodeFormatInformation decodeFormatInformation:formatInfoBits1 maskedFormatInfo2:formatInfoBits2];
  if (self.parsedFormatInfo != nil) {
    return self.parsedFormatInfo;
  }
  if (error) *error = ZXFormatErrorInstance();
  return nil;
}

- (ZXQRCodeVersion *)readVersionWithError:(NSError **)error {
  if (self.parsedVersion != nil) {
    return self.parsedVersion;
  }
  int dimension = self.bitMatrix.height;
  int provisionalVersion = (dimension - 17) / 4;
  if (provisionalVersion <= 6) {
    return [ZXQRCodeVersion versionForNumber:provisionalVersion];
  }
  int versionBits = 0;
  int ijMin = dimension - 11;

  for (int j = 5; j >= 0; j--) {

    for (int i = dimension - 9; i >= ijMin; i--) {
      versionBits = [self copyBit:i j:j versionBits:versionBits];
    }

  }

  ZXQRCodeVersion *theParsedVersion = [ZXQRCodeVersion decodeVersionInformation:versionBits];
  if (theParsedVersion != nil && theParsedVersion.dimensionForVersion == dimension) {
    self.parsedVersion = theParsedVersion;
    return self.parsedVersion;
  }
  versionBits = 0;

  for (int i = 5; i >= 0; i--) {
    for (int j = dimension - 9; j >= ijMin; j--) {
      versionBits = [self copyBit:i j:j versionBits:versionBits];
    }
  }

  theParsedVersion = [ZXQRCodeVersion decodeVersionInformation:versionBits];
  if (theParsedVersion != nil && theParsedVersion.dimensionForVersion == dimension) {
    self.parsedVersion = theParsedVersion;
    return self.parsedVersion;
  }
  if (error) *error = ZXFormatErrorInstance();
  return nil;
}

- (int)copyBit:(int)i j:(int)j versionBits:(int)versionBits {
  BOOL bit = self.shouldMirror ? [self.bitMatrix getX:j y:i] : [self.bitMatrix getX:i y:j];
  return bit ? (versionBits << 1) | 0x1 : versionBits << 1;
}

- (ZXByteArray *)readCodewordsWithError:(NSError **)error {
  ZXQRCodeFormatInformation *formatInfo = [self readFormatInformationWithError:error];
  if (!formatInfo) {
    return nil;
  }

  ZXQRCodeVersion *version = [self readVersionWithError:error];
  if (!version) {
    return nil;
  }

  // Get the data mask for the format used in this QR Code. This will exclude
  // some bits from reading as we wind through the bit matrix.
  ZXQRCodeDataMask *dataMask = [ZXQRCodeDataMask forReference:[formatInfo dataMask]];
  int dimension = self.bitMatrix.height;
  [dataMask unmaskBitMatrix:self.bitMatrix dimension:dimension];

  ZXBitMatrix *functionPattern = [version buildFunctionPattern];

  BOOL readingUp = YES;
  ZXByteArray *result = [[ZXByteArray alloc] initWithLength:version.totalCodewords];
  int resultOffset = 0;
  int currentByte = 0;
  int bitsRead = 0;
  // Read columns in pairs, from right to left
  for (int j = dimension - 1; j > 0; j -= 2) {
    if (j == 6) {
      // Skip whole column with vertical alignment pattern;
      // saves time and makes the other code proceed more cleanly
      j--;
    }
    // Read alternatingly from bottom to top then top to bottom
    for (int count = 0; count < dimension; count++) {
      int i = readingUp ? dimension - 1 - count : count;
      for (int col = 0; col < 2; col++) {
        // Ignore bits covered by the function pattern
        if (![functionPattern getX:j - col y:i]) {
          // Read a bit
          bitsRead++;
          currentByte <<= 1;
          if ([self.bitMatrix getX:j - col y:i]) {
            currentByte |= 1;
          }
          // If we've made a whole byte, save it off
          if (bitsRead == 8) {
            result.array[resultOffset++] = (int8_t) currentByte;
            bitsRead = 0;
            currentByte = 0;
          }
        }
      }
    }
    readingUp ^= YES; // readingUp = !readingUp; // switch directions
  }
  if (resultOffset != [version totalCodewords]) {
    if (error) *error = ZXFormatErrorInstance();
    return nil;
  }
  return result;
}

- (void)remask {
  if (!self.parsedFormatInfo) {
    return; // We have no format information, and have no data mask
  }
  ZXQRCodeDataMask *dataMask = [ZXQRCodeDataMask forReference:self.parsedFormatInfo.dataMask];
  int dimension = self.bitMatrix.height;
  [dataMask unmaskBitMatrix:self.bitMatrix dimension:dimension];
}

- (void)setMirror:(BOOL)mirror {
  self.parsedVersion = nil;
  self.parsedFormatInfo = nil;
  self.shouldMirror = mirror;
}

- (void)mirror {
  for (int x = 0; x < self.bitMatrix.width; x++) {
    for (int y = x + 1; y < self.bitMatrix.height; y++) {
      if ([self.bitMatrix getX:x y:y] != [self.bitMatrix getX:y y:x]) {
        [self.bitMatrix flipX:y y:x];
        [self.bitMatrix flipX:x y:y];
      }
    }
  }
}

@end