package com.srv4pos.server.api.category;
   
   import com.srv4pos.server.api.ServiceFactory;
   import com.srv4pos.server.api.exceptions.NotFoundJsonException;
   import com.srv4pos.server.api.infrastructure.IdentifierInfo;
   import com.srv4pos.server.api.infrastructure.credentials.Credentials;
   import com.srv4pos.server.api.infrastructure.http.HttpHelper;
   import com.srv4pos.server.api.infrastructure.http.Transport;
   import com.srv4pos.server.api.infrastructure.picture.CategoryPictureInfo;
  import com.srv4pos.server.api.seller.SellerService;
  import com.srv4pos.commons.io.IOUtils;
  
  import java.io.InputStream;
  import java.net.URL;
  import java.util.List;
  
  import static com.srv4pos.server.api.infrastructure.DiagnosticsUtil.assertExceptionThrown;
  import static com.srv4pos.server.api.infrastructure.DiagnosticsUtil.assertPicture;
  import static org.junit.Assert.assertEquals;
  
  /**
   * <p>User: Kirill, Date: 11.09.13 16:18</p>.
   */
  public class CategoryServiceSample {
      private static final String MAIN_PICTURE_FILENAME = "MAIN.PNG";
  
      private static final String FIRST_CATEGORY_NAME = "Test";
      private static final String SECOND_CATEGORY_NAME = "Test 2";
  
      private final SellerService sellerService;
      private final CategoryService categoryService;
  
      public CategoryServiceSample(URL url, Credentials credentials, Transport transport) {
          ServiceFactory serviceFactory = new ServiceFactory(url, credentials, transport);
          categoryService = serviceFactory.getCategoryService();
          sellerService = serviceFactory.getSellerService();
      }
  
      public void test() throws Exception {
  
          // get current version of the seller from server
          int currentSellerVersion = sellerService.getThisVersion().getVersion();
  
          // create test category
          CategoryInfo firstCategory = createAndSaveCategory(currentSellerVersion, FIRST_CATEGORY_NAME);
          currentSellerVersion++;
  
          final CategoryInfo secondCategory = createAndSaveCategory(currentSellerVersion, SECOND_CATEGORY_NAME);
          currentSellerVersion++;
  
          //Retrieve all categories from the server
          List<CategoryInfo> categories = categoryService.list(null);
  
          assertEquals("Make sure server returns right amount of categories ", 2, categories.size());
          assertEquals("Name mismatch for first category. Make sure server return right data ", FIRST_CATEGORY_NAME, categories.get(0).getName());
          assertEquals("Name mismatch for second category. Make sure server return right data", SECOND_CATEGORY_NAME, categories.get(1).getName());
  
          //Delete the second category from the server
          categoryService.delete(currentSellerVersion, secondCategory.getIdentifier());
  
          //Assert exception. Category must be deleted, so when we try to retrieve if from server, we must get NotFoundJsonException
          assertExceptionThrown("Category must be deleted", NotFoundJsonException.class, new Runnable() {
              public void run() {
                  categoryService.get(null, secondCategory.getIdentifier());
              }
          });
  
          //Retrieve all categories from the server
          categories = categoryService.list(null);
  
          assertEquals("Make sure server returns right amount of categories", 1, categories.size());
          assertEquals("Name mismatch for first category. Make sure server return right data", FIRST_CATEGORY_NAME, categories.get(0).getName());
      }
  
      public void testPictures() throws Exception {
  
          Integer currentSellerVersion = sellerService.getThisVersion().getVersion();
  
          String categoryId = createAndSaveCategory(currentSellerVersion, "Category 1").getIdentifier();
          currentSellerVersion++;
  
  
          // pictures
  
          URL pictureUrl = super.getClass().getResource("test.png");
          InputStream pictureStream = pictureUrl.openStream();
  
          try {
              categoryService.putPicture(currentSellerVersion, categoryId, MAIN_PICTURE_FILENAME, pictureStream, HttpHelper.CONTENT_TYPE_PNG);
              currentSellerVersion++;
          } finally {
              IOUtils.closeQuietly(pictureStream);
          }
  
          int uploadedPictureVersion = currentSellerVersion;
  
          InputStream pictureFromServer = categoryService.getPicture(null, categoryId, MAIN_PICTURE_FILENAME);
          assertPicture("Make sure uploaded picture matches to expected picture",
                  pictureUrl.openStream(),
                 pictureFromServer);
 
         List<String> paths = categoryService.getPicturePath(null, categoryId);
         assertEquals(paths.size(), 1);
 
         List<CategoryPictureInfo> pictures = categoryService.listDiffPicture(currentSellerVersion, currentSellerVersion);
         assertEquals("Check amount of changed pictures", 1, pictures.size());
 
         CategoryPictureInfo picture = pictures.get(0);
 
         assertEquals("Make sure can recognize not-deleted pictures", picture.isDeleted(), false);
 
         InputStream pictureFromHistory = categoryService.getPictureFromHistory(picture.getVersion(), categoryId, picture.getFilename());
 
         assertPicture("Verify server stores history for the pictures",
                 pictureUrl.openStream(),
                 pictureFromHistory);
 
         categoryService.deletePicture(uploadedPictureVersion, categoryId, MAIN_PICTURE_FILENAME);
         currentSellerVersion++;
 
         pictures = categoryService.listDiffPicture(uploadedPictureVersion, currentSellerVersion);
         assertEquals("Make sure can recognize deleted pictures", 2, pictures.size());
 
         final CategoryPictureInfo deletedPicture = pictures.get(0);
 
         assertEquals("Verify 'deleted' flag for deleted picture", deletedPicture.isDeleted(), true);
         assertEquals("Verify version of deleted picture is correct", deletedPicture.getVersion(), currentSellerVersion);
         assertEquals("Verify filename matches to expected ", deletedPicture.getFilename(), MAIN_PICTURE_FILENAME);
         assertEquals("Verify picture belongs to correct category", deletedPicture.getEntityIdentifier(), categoryId);
 
         // null because it was not modified since uploadedPictureVersion
         assertEquals("Make sure server detects when picture was not modified after deletion",
                 null,
                 categoryService.getPicture(currentSellerVersion, deletedPicture.getEntityIdentifier(), MAIN_PICTURE_FILENAME));
 
 
         assertExceptionThrown("Server must respond 404 because picture was deleted!", NotFoundJsonException.class, new Runnable() {
             public void run() {
                 categoryService.getPicture(sellerService.getThisVersion().getVersion() - 1, deletedPicture.getEntityIdentifier(), MAIN_PICTURE_FILENAME);
             }
         });
     }
 
 
     private CategoryInfo createAndSaveCategory(final int sellerVersion, final String categoryName) {
         CategoryInfo categoryInfo = new CategoryInfo();
         categoryInfo.setName(categoryName);
 
         IdentifierInfo identifierInfo = categoryService.create(sellerVersion, categoryInfo);
 
         categoryInfo.setIdentifier(identifierInfo.getIdentifier());
         return categoryInfo;
     }
 }