/*
   Copyright (c) 2008 Health Market Science, 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.
  */
  
  package com.healthmarketscience.jackcess.impl;
  
  import java.lang.reflect.Field;
  import java.nio.ByteBuffer;
  import java.util.HashMap;
  import java.util.Map;
  
  import com.healthmarketscience.jackcess.ColumnBuilder;
  import com.healthmarketscience.jackcess.Cursor;
  import com.healthmarketscience.jackcess.CursorBuilder;
  import com.healthmarketscience.jackcess.DataType;
  import com.healthmarketscience.jackcess.Database;
  import com.healthmarketscience.jackcess.DateTimeType;
  import com.healthmarketscience.jackcess.Index;
  import com.healthmarketscience.jackcess.IndexBuilder;
  import com.healthmarketscience.jackcess.Row;
  import com.healthmarketscience.jackcess.Table;
  import com.healthmarketscience.jackcess.TableBuilder;
  import static com.healthmarketscience.jackcess.TestUtil.*;
  import static com.healthmarketscience.jackcess.impl.JetFormatTest.*;
  import static org.junit.jupiter.api.Assertions.*;
  import org.junit.jupiter.api.Test;
  
  /**
   * @author James Ahlborn
   */
  public class IndexCodesTest {
  
    private static final Map<Character,String> SPECIAL_CHARS =
      new HashMap<Character,String>();
    static {
      SPECIAL_CHARS.put('\b', "\\b");
      SPECIAL_CHARS.put('\t', "\\t");
      SPECIAL_CHARS.put('\n', "\\n");
      SPECIAL_CHARS.put('\f', "\\f");
      SPECIAL_CHARS.put('\r', "\\r");
      SPECIAL_CHARS.put('\"', "\\\"");
      SPECIAL_CHARS.put('\'', "\\'");
      SPECIAL_CHARS.put('\\', "\\\\");
    }
  
    @Test
    public void testIndexCodes() throws Exception
    {
      doTestDb(Basename.INDEX_CODES);
    }
  
    @Test
    public void testEmoticons() throws Exception
    {
      doTestDb(Basename.EMOTICONS);
    }
  
    /**
     * Tests the "international ext" characters, whose codes end with a suffix
     * whose length grows with the number of characters which took that path.
     * The expected keys were read back out of the index pages Access built for
     * U+3041 (crazy flag set) and U+3042 (crazy flag clear).
     */
    @Test
    public void testInternationalExtCodes() throws Exception
    {
      try(Database db = create(Database.FileFormat.V2010)) {
  
        IndexData.ColumnDescriptor col = getTextIndexColumn(db);
  
        // one suffix repeat covers up to 7 chars, so these are the two
        // boundaries either side of the first extra repeat
        assertIndexKey("7f7f02010101a0ff0280ff8000", col, repeat('\u3041', 1));
        assertIndexKey("7f7f02010101ff0280ff8000", col, repeat('\u3042', 1));
        assertIndexKey(
            "7f7f027f027f027f027f027f027f027f02010101aaaaa8ff028080ff808000",
            col, repeat('\u3041', 8));
        assertIndexKey(
            "7f7f027f027f027f027f027f027f027f02010101ff028080ff808000",
            col, repeat('\u3042', 8));
        assertIndexKey(
            "7f7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
            "010101aaaaaaaaaaa0ff02808080ff80808000",
            col, repeat('\u3041', 16));
      }
    }
  
   /**
    * Tests the surrogate chars in the general collation.  The weight table
    * gives the high surrogates four runs, one of which has no weight at all,
    * and the low surrogates one piecewise run.  The expected keys were read
    * back out of the index Access built.
    */
   @Test
   public void testGeneralSurrogates() throws Exception
   {
     try(Database db = create(Database.FileFormat.V2010)) {
 
       IndexData.ColumnDescriptor col = getTextIndexColumn(db);
 
       // U+D800 to U+D83F, primary = cp - 10238, extra byte 0x3f
       assertIndexKey("7fb002b4f80e020e02013f3f00", col, pair(0x10000) + "aa");
       assertIndexKey("7fb03fb6fc0e020e02013f3f00", col, pair(0x1F600) + "aa");
 
       // U+D840 to U+D87F, primary = cp + 9666, extra byte 0x3e
       assertIndexKey("7ffe02b4f80e020e02013e3f00", col, pair(0x20000) + "aa");
       assertIndexKey("7ffe41b8ff0e020e02013e3f00", col, pair(0x2FFFF) + "aa");
 
       // U+D880 to U+DB7F, no weight, so the high surrogate writes nothing at
       // all and the tail carries one extra byte rather than two
       assertIndexKey("7fb4f80e020e02013f00", col, pair(0x30000) + "aa");
       assertIndexKey("7fb8ff0e020e02013f00", col, pair(0xEFFFF) + "aa");
 
       // U+DB80 to U+DBFF, primary = cp + 9090, extra byte 0x3e
       assertIndexKey("7fff02b4f80e020e02013e3f00", col, pair(0xF0000) + "aa");
       assertIndexKey("7fff81b8ff0e020e02013e3f00", col, pair(0x10FFFF) + "aa");
 
       // the pair in the other positions, which moves the separator
       assertIndexKey("7f0e02fe02b4f80e0201023e3f00", col,
                      "a" + pair(0x20000) + "a");
       assertIndexKey("7f0e020e02b4f80e020102023f00", col,
                      "aa" + pair(0x30000) + "a");
     }
   }
 
   /**
    * Tests the surrogate chars in the general legacy collation, which gives
    * them no weight at all, so both halves of a pair are ignored.  The
    * expected keys were read back out of the index Access built.
    */
   @Test
   public void testGeneralLegacySurrogates() throws Exception
   {
     try(Database db = create(Database.FileFormat.V2003)) {
 
       IndexData.ColumnDescriptor col = getTextIndexColumn(db);
 
       // 4a is the legacy code for 'a'.  every one of these is the key for
       // "aa", whatever the code point and wherever it sits in the string
       for(int cp : new int[]{0x10000, 0x20000, 0x30000, 0xF0000, 0x10FFFF}) {
         assertIndexKey("7f4a4a0100", col, pair(cp) + "aa");
         assertIndexKey("7f4a4a0100", col, "a" + pair(cp) + "a");
         assertIndexKey("7f4a4a0100", col, "aa" + pair(cp));
         assertIndexKey("7f4a4a4a0100", col, "aa" + pair(cp) + "a");
       }
     }
   }
 
   private static String pair(int codePoint) {
     return new String(Character.toChars(codePoint));
   }
 
   /**
    * Tests that a key longer than the maximum is truncated the way Access
    * truncates it, with a digest of the discarded bytes.  The expected key was
    * read back out of the index page Access built.
    */
   @Test
   public void testTruncatedKey() throws Exception
   {
     try(Database db = create(Database.FileFormat.V2010)) {
 
       IndexData.ColumnDescriptor col = getTextIndexColumn(db);
 
       // 200 chars of U+3041 encode to more than the maximum key length, so
       // Access keeps the leading 508 bytes and ends the key with a digest of
       // everything it discarded
       byte[] fullKey = encodeIndexKey(col, repeat('\u3041', 200));
       assertEquals(533, fullKey.length);
 
       // the truncated form is what Access actually stores
       assertEquals(
           "7f7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f02" +
           "7f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f027f" +
           "027f027f02010101aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
           "aaaaaaaaaaaaaaaaa8ff0280808080808080808080808080808080808080808080" +
           "80808080808080ff8080808080d06b",
           toCompactHex(IndexData.truncateEntryBytes(fullKey)));
     }
   }
 
   private static IndexData.ColumnDescriptor getTextIndexColumn(Database db)
     throws Exception
   {
     Table t = new TableBuilder("test")
       .addColumn(new ColumnBuilder("data", DataType.MEMO))
       .addIndex(new IndexBuilder("dataidx").addColumns("data"))
       .toTable(db);
     IndexImpl idx = (IndexImpl)t.getIndex("dataidx");
     return idx.getIndexData().getColumns().get(0);
   }
 
   private static void assertIndexKey(String expected,
                                      IndexData.ColumnDescriptor col,
                                      String value)
     throws Exception
   {
     assertEquals(expected, toCompactHex(encodeIndexKey(col, value)),
                  "key for " + toUnicodeStr(value));
   }
 
   private static byte[] encodeIndexKey(IndexData.ColumnDescriptor col,
                                        String value)
     throws Exception
   {
     ByteUtil.ByteStream bout = new ByteUtil.ByteStream();
     col.writeValue(value, bout);
     return bout.toByteArray();
   }
 
   private static String repeat(char c, int num)
   {
     StringBuilder sb = new StringBuilder(num);
     for(int i = 0; i < num; ++i) {
       sb.append(c);
     }
     return sb.toString();
   }
 
   private static String toCompactHex(byte[] bytes)
   {
     StringBuilder sb = new StringBuilder(bytes.length * 2);
     for(byte b : bytes) {
       sb.append(String.format("%02x", b));
     }
     return sb.toString();
   }
 
   private static void doTestDb(Basename dbBaseName) throws Exception
   {
     for (final TestDB testDB : TestDB.getSupportedForBasename(dbBaseName, true)) {
       try (Database db = openMem(testDB)) {
         db.setDateTimeType(DateTimeType.DATE);
 
         for(Table t : db) {
           for(Index index : t.getIndexes()) {
             checkIndexEntries(testDB, t, index);
           }
         }
       }
     }
   }
 
   public static void checkIndexEntries(final TestDB testDB, Table t, Index index) throws Exception
   {
     Cursor cursor = CursorBuilder.createCursor(index);
     while(cursor.moveToNextRow()) {
 
       Row row = cursor.getCurrentRow();
 
       Object data = row.get("data");
       if((testDB.getExpectedFileFormat() == Database.FileFormat.V1997) &&
          (data instanceof String) && ((String)data).contains("\uFFFD")) {
         // this row has a character not supported in the v1997 charset
         continue;
       }
 
       Cursor.Position curPos = cursor.getSavepoint().getCurrentPosition();
       boolean success = false;
       try {
         findRow(testDB, t, index, row, curPos);
         success = true;
       } finally {
         if(!success) {
           System.out.println("CurPos: " + curPos);
           System.out.println("Value: " + row + ": " +
                              toUnicodeStr(row.get("data")));
         }
       }
     }
 
   }
 
   private static void findRow(final TestDB testDB, Table t, Index index,
                               Row expectedRow,
                               Cursor.Position expectedPos)
     throws Exception
   {
     Object[] idxRow = ((IndexImpl)index).constructIndexRow(expectedRow);
     Cursor cursor = CursorBuilder.createCursor(index, idxRow, idxRow);
 
     Cursor.Position startPos = cursor.getSavepoint().getCurrentPosition();
 
     cursor.beforeFirst();
     while(cursor.moveToNextRow()) {
       Row row = cursor.getCurrentRow();
       if(expectedRow.equals(row)) {
         // verify that the entries are indeed equal
         Cursor.Position curPos = cursor.getSavepoint().getCurrentPosition();
         assertEquals(entryToString(expectedPos), entryToString(curPos));
         return;
       }
     }
 
     fail("testDB: " + testDB + ";\nCould not find expected row " + expectedRow + " starting at " +
          entryToString(startPos));
   }
 
   public static String toUnicodeStr(Object obj) {
     StringBuilder sb = new StringBuilder();
     for(char c : obj.toString().toCharArray()) {
       sb.append(toUnicodeStr(c)).append(" ");
     }
     return sb.toString();
   }
 
   private static String toUnicodeStr(char c) {
     String specialStr = SPECIAL_CHARS.get(c);
     if(specialStr != null) {
       return specialStr;
     }
 
     String digits = Integer.toHexString(c).toUpperCase();
     while(digits.length() < 4) {
       digits = "0" + digits;
     }
     return "\\u" + digits;
   }
 
   public static String entryToString(Cursor.Position curPos)
     throws Exception
   {
     Field eField = curPos.getClass().getDeclaredField("_entry");
     eField.setAccessible(true);
     IndexData.Entry entry = (IndexData.Entry)eField.get(curPos);
     Field ebField = entry.getClass().getDeclaredField("_entryBytes");
     ebField.setAccessible(true);
     byte[] entryBytes = (byte[])ebField.get(entry);
 
     return ByteUtil.toHexString(ByteBuffer.wrap(entryBytes),
                                 0, entryBytes.length, false);
   }
 
 }