/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.myfaces.tobago.component;
  
  import org.apache.myfaces.tobago.internal.config.AbstractTobagoTestBase;
  import org.junit.jupiter.api.Assertions;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  import javax.faces.model.ListDataModel;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  public class UISheetUnitTest extends AbstractTobagoTestBase {
  
    private static final String[] DATA = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    private List<String> nineRows;
    private UISheet data;
    private UISheet unknown;
  
    @Override
    @BeforeEach
    public void setUp() throws Exception {
      super.setUp();
      nineRows = new ArrayList<>();
      Collections.addAll(nineRows, DATA);
  
      data = new UISheet();
      data.setValue(new ListDataModel(nineRows));
  
      unknown = new UISheet();
      unknown.setValue(new DataModelWithUnknownRows(nineRows));
    }
  
    @Test
    public void test5RowsPerPage() {
      data.setRows(5);
      // having rowCount 9 and 5 rows to display it looks like this (rotated, X X X X X means one page with 5 rows):
      // X X X X X
      // X X X X
      Assertions.assertEquals(2, data.getPages(), "number of pages");
    }
  
    @Test
    public void test9RowsPerPage() {
      data.setRows(9);
      // X X X X X X X X X
      Assertions.assertEquals(1, data.getPages(), "number of pages");
    }
  
    @Test
    public void test2RowsPerPage() {
      data.setRows(2);
      // X X
      // X X
      // X X
      // X X
      // X
      Assertions.assertEquals(5, data.getPages(), "number of pages");
    }
  
    @Test
    public void test3RowsPerPage() {
      data.setRows(3);
      // X X X
      // X X X
      // X X X
      Assertions.assertEquals(3, data.getPages(), "number of pages");
    }
  
    @Test
    public void test1RowPerPage() {
      data.setRows(1);
      // X
      // X
      // X
      // X
      // X
      // X
      // X
      // X
     // X
     Assertions.assertEquals(9, data.getPages(), "number of pages");
   }
 
   @Test
   public void testAllRowsPerPage() {
     data.setRows(0); // zero means all
     // X X X X X X X X X
     Assertions.assertEquals(1, data.getPages(), "number of pages");
   }
 
   @Test
   public void testCurrentPageRows5() {
     data.setRows(5);
     // initially first = 0
     // * X X X X
     // X X X X
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(true, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(5);
     // now we set the first (show as an F)
     // X X X X X
     // * X X X
     Assertions.assertEquals(1, data.getCurrentPage(), "current page");
     Assertions.assertEquals(false, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(0);
     // * X X X X
     // X X X X
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(true, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(4);
     // X X X X *
     // X X X X
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(false, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(100);
     // out of rage
     Assertions.assertEquals(1, data.getCurrentPage(), "current page");
     Assertions.assertEquals(false, data.isAtBeginning(), "is at beginning");
   }
 
   @Test
   public void testCurrentPageRows20() {
     data.setRows(20); // more rows than data entries
     // initially first = 0
     // * X X X X X X X X
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(true, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(8);
     // now we set the first (show as an F)
     // X X X X X X X X *
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(false, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(0);
     // * X X X X X X X X
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(true, data.isAtBeginning(), "is at beginning");
 
     data.setFirst(100);
     // out of range
     Assertions.assertEquals(0, data.getCurrentPage(), "current page");
     Assertions.assertEquals(false, data.isAtBeginning(), "is at beginning");
   }
 
   @Test
   public void testRowData() {
     data.setRowIndex(0);
     Assertions.assertEquals("one", data.getRowData());
     data.setRowIndex(8);
     Assertions.assertEquals("nine", data.getRowData());
     data.setRowIndex(9);
     try {
       data.getRowData();
       Assertions.fail();
     } catch (final IllegalArgumentException e) {
       // okay: row is unavailable
     }
   }
 
   @Test
   public void testHasRowCount() {
     Assertions.assertEquals(true, data.hasRowCount(), "has row count");
     Assertions.assertEquals(false, unknown.hasRowCount(), "has row count");
   }
 
   @Test
   public void testRowsUnlimited() {
     data.setRows(5);
     unknown.setRows(5);
 
     Assertions.assertEquals(false, data.isRowsUnlimited(), "unlimited rows");
     Assertions.assertEquals(false, unknown.isRowsUnlimited(), "unlimited rows");
 
     data.setRows(0);
     unknown.setRows(0);
 
     Assertions.assertEquals(true, data.isRowsUnlimited(), "unlimited rows");
     Assertions.assertEquals(true, unknown.isRowsUnlimited(), "unlimited rows");
   }
 
   @Test
   public void testNeedMoreThanOnePage() {
 
     // known length:
 
     data.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(false, data.needMoreThanOnePage(), "need more than one page");
 
     data.setRows(5);
     // * X X X X
     // X X X X
     Assertions.assertEquals(true, data.needMoreThanOnePage(), "need more than one page");
 
     data.setRows(20);
     // * X X X X X X X X
     Assertions.assertEquals(false, data.needMoreThanOnePage(), "need more than one page");
 
     // unknown length:
 
     unknown.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(false, unknown.needMoreThanOnePage(), "need more than one page");
 
     unknown.setRows(5);
     // * X X X X
     // X X X X
     Assertions.assertEquals(true, unknown.needMoreThanOnePage(), "need more than one page");
 
     unknown.setRows(20);
     // * X X X X X X X X
     Assertions.assertEquals(true, unknown.needMoreThanOnePage(), "need more than one page");
   }
 
   @Test
   public void testFirstRowIndexOfLastPage() {
 
     // known length:
 
     data.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(0, data.getFirstRowIndexOfLastPage(), "first row index of last page");
 
     data.setRows(5);
     // * X X X X
     // X X X X
     Assertions.assertEquals(5, data.getFirstRowIndexOfLastPage(), "first row index of last page");
 
     data.setRows(20);
     // * X X X X X X X X
     Assertions.assertEquals(0, data.getFirstRowIndexOfLastPage(), "first row index of last page");
 
     // unknown length:
 
     unknown.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(0, unknown.getFirstRowIndexOfLastPage(), "first row index of last page");
 
     unknown.setRows(5);
     // * X X X X
     // X X X X
     try {
       unknown.getFirstRowIndexOfLastPage();
       Assertions.fail("first row index of last page");
     } catch (final IllegalArgumentException e) {
       // okay: last page can't determined
     }
 
     unknown.setRows(20);
     // * X X X X X X X X
     try {
       unknown.getFirstRowIndexOfLastPage();
       Assertions.fail("first row index of last page");
     } catch (final IllegalArgumentException e) {
       // okay: last page can't determined
     }
   }
 
   @Test
   public void testLastRowIndexOfCurrentPage() {
 
     // known length:
 
     data.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(9, data.getLastRowIndexOfCurrentPage(), "last row index of current page");
 
     data.setRows(5);
     // * X X X X
     // X X X X
     Assertions.assertEquals(5, data.getLastRowIndexOfCurrentPage(), "last row index of current page");
 
     data.setRows(20);
     // * X X X X X X X X
     Assertions.assertEquals(9, data.getLastRowIndexOfCurrentPage(), "last row index of current page");
 
     // unknown length:
 
     unknown.setRows(0);
     // * X X X X X X X X
     try {
       unknown.getLastRowIndexOfCurrentPage();
       Assertions.fail("last row index of current page");
     } catch (final IllegalArgumentException e) {
       // okay: last row index of current page can't determined
     }
 
     unknown.setRows(5);
     // * X X X X
     // X X X X
     try {
       unknown.getLastRowIndexOfCurrentPage();
       Assertions.fail("last row index of current page");
     } catch (final IllegalArgumentException e) {
       // okay: last row index of current page can't determined
     }
 
     unknown.setRows(20);
     // * X X X X X X X X
     try {
       unknown.getLastRowIndexOfCurrentPage();
       Assertions.fail("last row index of current page");
     } catch (final IllegalArgumentException e) {
       // okay: last row index of current page can't determined
     }
   }
 
   @Test
   public void testGetCurrentPageOnUnknown() {
 
     // unknown length:
 
     unknown.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(0, unknown.getCurrentPage(), "current page");
 
     unknown.setRows(5);
     // * X X X X
     // X X X X
     Assertions.assertEquals(0, unknown.getCurrentPage(), "current page");
 
     unknown.setFirst(5);
     // X X X X X
     // * X X X
     Assertions.assertEquals(1, unknown.getCurrentPage(), "current page");
   }
 
   @Test
   public void testGetPagesOnUnknown() {
 
     // unknown length:
 
     unknown.setRows(0);
     // * X X X X X X X X
     Assertions.assertEquals(1, unknown.getPages(), "pages");
 
     unknown.setRows(5);
     // * X X X X
     // X X X X
     try {
       unknown.getPages();
       Assertions.fail("pages");
     } catch (final IllegalArgumentException e) {
       // okay: pages can't determined
     }
   }
 
   @Test
   public void testDynamicRemoval() {
     nineRows.remove(0);
     nineRows.remove(0);
     nineRows.remove(0);
     data.setRows(5);
     Assertions.assertEquals(2, data.getPages());
     nineRows.remove(0);
     nineRows.remove(0);
     nineRows.remove(0);
     Assertions.assertEquals(1, data.getPages());
   }
 
   @Test
   public void testStripRowIndex() {
     Assertions.assertEquals("comp1:comp2", new UISheet().stripRowIndex("123:comp1:comp2"));
     Assertions.assertEquals("comp1:comp2", new UISheet().stripRowIndex("comp1:comp2"));
   }
 
   private static class DataModelWithUnknownRows extends ListDataModel {
 
     DataModelWithUnknownRows(final List list) {
       super(list);
     }
 
     @Override
     public int getRowCount() {
       return -1;
     }
   }
 
 }