// POST: api/Categories/products

        //[Route("products")]
        //[HttpPost]
        //public IHttpActionResult PostCategoriesWithProducts(ICollection<Category> categories)
        //{
        //    if (!ModelState.IsValid)
        //    {
        //        return BadRequest(ModelState);
        //    }

        //    try
        //    {
        //        CategoryProductRepository categpryProductRepo = new CategoryProductRepository(new MyRoomDbContext());
              
        //        categpryProductRepo.InsertCategoryProduct(categories.ToList());

        //        return Ok("Category Product Inserted");
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}
        // POST: api/Categories
        public IHttpActionResult PostCategories(CategoryViewModel categoryViewModel)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                //if (category.Modules != null)
                //{ 
                //    categoryRepo.Update(category);
                //} 
                Category category = CategoryMapper.CreateModel(categoryViewModel);
                categoryRepo.ModuleStateUnchange(category);
                 
                if (!category.IsFirst)
                {
                    category.Modules = null;
                }

                categoryRepo.Insert(category);

                //busco hotel con el catalogo seleccionado
                ActiveHotelCatalogRepository hotelCatalog = new ActiveHotelCatalogRepository(new MyRoomDbContext());
                int hotelId = hotelCatalog.GetByCatalogId(categoryViewModel.CatalogId);
                if (hotelId > 0)
                { 
                    //inserto categorias a hotel relacionado
                    ActiveHotelCategoryRepository activeHotelCategoryRepo = new ActiveHotelCategoryRepository(new MyRoomDbContext());
                    List<ActiveHotelCategory> hotelscategories = new List<ActiveHotelCategory>();
                    hotelscategories.Add(new ActiveHotelCategory() { IdCategory = category.CategoryId, IdHotel = hotelId });
                    activeHotelCategoryRepo.InsertActiveHotelCategory(hotelscategories, hotelId, true);
                }
                return Ok(category);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        // POST: api/modules
        public IHttpActionResult Post(ModuleViewModel moduleViewModel)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            try
            {

                Module module = ModuleMapper.CreateModel(moduleViewModel);
                moduleRepo.CatalogStateUnchange(module);
                moduleRepo.Insert(module);

                //busco hotel con el catalogo seleccionado
                ActiveHotelCatalogRepository hotelCatalog = new ActiveHotelCatalogRepository(new MyRoomDbContext());
                int hotelId = hotelCatalog.GetByCatalogId(moduleViewModel.CatalogId);
                if (hotelId > 0)
                { 
                    //inserto categorias a hotel relacionado
                    ActiveHotelModuleRepository activeHotelModuleRepo = new ActiveHotelModuleRepository(new MyRoomDbContext());
                    List<ActiveHotelModule> hotelModules = new List<ActiveHotelModule>();
                    hotelModules.Add(new ActiveHotelModule() { IdModule = module.ModuleId, IdHotel = hotelId });
                    activeHotelModuleRepo.InsertActiveHotelModule(hotelModules, hotelId);
                }
                return Ok(module.ModuleId);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            
        }
        public IHttpActionResult PostHotelsWithCatalogues(ActiveHotelCataloguesViewModel hotelsCataloguesViewModel)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            ActiveHotelCatalogRepository hotelCatalogRepo = new ActiveHotelCatalogRepository(new MyRoomDbContext());

            List<ActiveHotelCatalogue> hotelCatalogues = ActiveHotelCatalogMapper.CreateModel(hotelsCataloguesViewModel);

            hotelCatalogRepo.InsertActiveHotelCatalogues(hotelCatalogues, hotelsCataloguesViewModel.HotelId);

            return Ok("Catalogues Assigned to hotels");
        }
        // POST: api/Products
        public IHttpActionResult PostProducts(ProductViewModel productViewModel)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            try
            {
                Product product = ProductMapper.CreateModel(productViewModel);
                productRepository.Insert(product);

                product.RelatedProducts = new List<RelatedProduct>();
                RelatedProductRepository relProdRepo = new RelatedProductRepository(new MyRoomDbContext());
                foreach (RelatedProduct rp in productViewModel.RelatedProducts)
                {
                    rp.IdProduct = product.Id;
                }
                relProdRepo.InsertRelatedProducts(productViewModel.RelatedProducts.ToList());

                //Inserta productos a ActiveHotelProduct
                ActiveHotelCatalogRepository hotelActiveRepo = new ActiveHotelCatalogRepository(relProdRepo.Context);
                //int hotelId = hotelActiveRepo.GetByCatalogId(productViewModel.CatalogId);
                
//                if (hotelId > 0)
  //              {
                    ActiveHotelProductRepository productHotelActiveRepo = new ActiveHotelProductRepository(relProdRepo.Context);
                    productHotelActiveRepo.Insert(new ActiveHotelProduct() { IdHotel = productViewModel.HotelId, IdProduct = product.Id, Active = true });
    //            }
                return Ok("Product Inserted");
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }