@Controller
@Slf4j
@ToString
public class ProductViewController {
	@Autowired
	ProductService 	productService; 
	//전체 도서
	@RequestMapping("/bookstore/product/productCeteList.do")
	public String listProduct(HttpSession session, Model model, 
			@RequestParam(value="pageNum",defaultValue="1") int currentPage,
			@RequestParam(defaultValue="4") int order,
			@RequestParam(defaultValue="국내도서")String cate, //1:국내도서
			@RequestParam(defaultValue="소설")String detail,
			@RequestParam(defaultValue="10") int count_num) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("store_product_searchcategoryName", cate);
		map.put("store_product_categoryname", detail);
		int count = productService.selectCategoryCount(map);
		PagingUtil page = 
				new PagingUtil(null,null,
						currentPage,count,count_num,10,
						"/bookstore/product/productCeteList.do","&detail="+detail+"&order="+order+"&count_num="+count_num+"&cate="+cate);
		map.put("start", page.getStartRow());
		map.put("end", page.getEndRow());
		map.put("order", order);
		List<ProductVO> list = productService.selectCategoryBook(map);
		String[] category = category();
		model.addAttribute("category", category);
		model.addAttribute("list", list);
		model.addAttribute("page", page.getPage());
		model.addAttribute("count", count);
		model.addAttribute("categoryTitle", detail);
		model.addAttribute("order", order);
		model.addAttribute("count_num", count_num);
		model.addAttribute("cate", cate);
		
		LocalDate now = LocalDate.now();
		model.addAttribute("now", now); 
		return "productListAll";
	}
	//베스트 도서
	@RequestMapping("/bookstore/product/productBestList.do")
	public ModelAndView BestListProduct() {
		ModelAndView mav = new ModelAndView();
		mav.setViewName("productListBest");
		//분야별 TOP 3
		String[] category = category();
		Map<String, List<ProductVO>> top3 = new HashMap<String, List<ProductVO>>();
		for(String cate : category) {
			List<ProductVO> top = productService.selectCateTop3(cate);
			top3.put(cate, top);
		}
		mav.addObject("top3", top3);
		mav.addObject("category", category);
		//월간 베스트 도서
		List<ProductVO> best = productService.selectBestBookList(0,1);
		//연간 베스트 도서
		List<ProductVO> best_y = productService.selectBestBookList(1,12);
		
		mav.addObject("bestList", best);
		mav.addObject("bestYear", best_y);
		log.debug("<<베스트 셀러>> : "+top3);
		return mav;
	}
	//베스트 도서
	@RequestMapping("/bookstore/product/productNewList.do")
	public ModelAndView NewListProduct() {
		ModelAndView mav = new ModelAndView();
		mav.setViewName("productListNew");
		//분야별 신규
		String[] category = category();
		Map<String, List<ProductVO>> new3 = new HashMap<String, List<ProductVO>>();
		for(String cate : category) {
			List<ProductVO> top = productService.selectCateNew(cate);
			new3.put(cate, top);
		}
		mav.addObject("new3", new3);
		mav.addObject("category", category);
		//국내&외국도서별 신규 도서
		List<ProductVO> inNew = productService.selectNew("국내도서");
		List<ProductVO> outNew = productService.selectNew("외국도서");
		mav.addObject("inNew", inNew);
		mav.addObject("outNew", outNew);
		return mav;
	}

	public String[] category(){
		String[] list = {"소설/시/희곡","인문학","컴퓨터","종교/역학","예술/대중문화","자기계발","외국어",
				"역사","경제경영","사회과학","과학","유아","어린이","소년",
				"수험서/자격증","참고서","만화","대학교재",
				"달력/기타","잡지","에세이","건강/취미"};
		return list;
	}
}

@Controller
@Slf4j
public class BookStorePaymentController {
	
	public static final String IMPORT_TOKEN_URL = "https://api.iamport.kr/users/getToken";
	public static final String IMPORT_CANCEL_URL = "https://api.iamport.kr/payments/cancel";
	public static final String KEY = "";  
	public static final String SECRET = "";
	
	@Autowired
	private BookStorePaymentService bookStorePaymentService;
	@Autowired
	private BookStorePaymentOrderService bookStorePaymentOrderService; 
	@Autowired
	private MemberService memberService;
	@Autowired
	
	//초기화
	@ModelAttribute
	public MemberVO initCommand() {
		return new MemberVO();
	}
	//장바구니 추가
	@PostMapping("/bookstore/payment/cart.do")
	@ResponseBody
	public Map<String,String> insertcartForm(HttpSession session, Model model, BookStorePaymentCartVO product) {
		String mem_id = (String)session.getAttribute("mem_id");
		Map<String, String> mapJson = new HashMap<String, String>();
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		log.debug("<<도서 정보>> : "+product);
		product.setMem_num(mem_num);
		Boolean check = true;
		if(product.getUsed_product_num() != 0) {//중고 확인
			//중고 중복 상품 확인
			BookStorePaymentCartVO used = bookStorePaymentService.selectEmptyUsed(product.getUsed_product_num(),mem_num);
			if(used != null) {
				mapJson.put("result", "existBook");
				return mapJson;
			}
			product.setCart_quantity(1);
			bookStorePaymentService.insertCart(product);
			check = false;
		}else {//신상
			List<BookStorePaymentCartVO> db_cartVO = bookStorePaymentService.selectCartList(mem_num);
			for(BookStorePaymentCartVO vo : db_cartVO) {//중복 상품 확인
				log.debug("<<신상 중복 확인>> : "+vo.getStore_product_num()+','+product.getStore_product_num()+','+vo.getStore_product_status());
				if(vo.getStore_product_num() == product.getStore_product_num() && vo.getStore_product_status() == 0) {
					int total = vo.getCart_quantity() + product.getCart_quantity();
					product.setCart_quantity(total);
					product.setMem_cart_num(vo.getMem_cart_num());
					bookStorePaymentService.updateCart(product);
					check = false;
					break;
				}
			}
			if(check) {//새상품 추가
				log.debug("<<카트 도서 추가>>"+product);
				bookStorePaymentService.insertCart(product);
			}
		}
		mapJson.put("result", "success");
		
		return mapJson;
	}
	//======================API 관련===========================//  
	//Token 값 발급
	public String tokenTest() {
		String token = "";
		try {
			token = bookStorePaymentService.getToken();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return token;//결제 취소로 보내줘야 함
	}
	//주문 취소
	@RequestMapping("/bookstore/payment/cancelPay.do")
	@ResponseBody
	public Map<String, Object> cancelPay(int order_num){
		Map<String, Object> mapJson = new HashMap<String, Object>();
		try {
			String token = tokenTest();
			if(token == null) {
				throw new Exception();
			}
			//주문 정보 가져오기
			String IMP_UID = bookStorePaymentOrderService.selectImp_uid(order_num);
			String reason = "단순 변심";
			int amount = bookStorePaymentService.paymentInfo(token, IMP_UID);
			bookStorePaymentService.cancelPay(token, IMP_UID, amount,reason);
			//주문 취소 정보 추가
			bookStorePaymentOrderService.updateCancelInfo(order_num, reason);
			//재고 변경
			List<BookStorePaymentOrderVO> list = bookStorePaymentOrderService.listOrder(order_num);
			bookStorePaymentOrderService.updateQuantity(list);
			//주문 취소 포인트 전환
			String point_reason = String.valueOf(order_num);
			//해당 주문 건의 포인트 조회
			bookStorePaymentOrderService.selectPoint(point_reason);
			mapJson.put("result", "success");
		} catch (Exception e) {
			e.printStackTrace();
			mapJson.put("result", "errorCancel");
		}
		log.debug("<<주문 취소-map>> : "+mapJson);
		return mapJson;
	}
	//======================장바구니FORM===========================//  
	@GetMapping("/bookstore/payment/cart.do")
	public String cartForm(HttpSession session, Model model, HttpServletRequest request) {
		log.debug("<<세션 확인 >> : "+session.getAttribute("cartList"));
		
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			return "redirect:/lm/login/template/loginMain.do?lo=1";
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		int grade = (Integer)session.getAttribute("mem_grade");
		
		double point = getPoint(grade);
		List<BookStorePaymentCartVO> list = bookStorePaymentService.selectCartList(mem_num);
		List<ProductVO> book_list = new ArrayList<ProductVO>();
		for(BookStorePaymentCartVO vo : list) {
			log.debug("<<중고 확인!!!!!!!!>> : "+vo);
			ProductVO product = bookStorePaymentService.selectDetailBook(vo.getStore_product_num());
			if(vo.getStore_product_status() == 1) {
				UsedVO used = bookStorePaymentService.selectUsedBook(vo.getUsed_product_num());
				log.debug("<<도서 중고 정보>> : "+used);
				product.setUsed_product_price(used.getUsed_product_price());
				product.setUsed_product_status(used.getUsed_product_status());
				product.setUsed_product_num(used.getUsed_product_num());
			}
			book_list.add(product);
		}
		
		log.debug("<<cart>> : "+list);
		log.debug("<<cart_book>> : "+book_list);
		
		model.addAttribute("list", list);
		model.addAttribute("book_list", book_list);
		model.addAttribute("point", point);
		log.debug("<<grade>>"+point);
		return "cart";
	}
	//책 삭제
	@RequestMapping("/bookstore/payment/Cartdelete.do")
	@ResponseBody
	public Map<String, Object> deleteCartBook(Integer mem_cart_num, HttpSession session){
		String mem_id = (String)session.getAttribute("mem_id");
		Map<String, Object> mapJson = new HashMap<String, Object>();
		if(mem_id == null) {
			mapJson.put("result", "logout");
		}
		log.debug("<<카드 삭제 번호>> : "+mem_cart_num);
		if(mem_id == null) {
			mapJson.put("result", "logout");
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		bookStorePaymentService.deleteCart(mem_cart_num);
		mapJson.put("result", "success");
		return mapJson;
	}
	//======================장바구니 > 결제 페이지===========================//  
	@PostMapping("/bookstore/payment/cartAction.do")
	@ResponseBody 
	public Map<String, Object> actionCart(@RequestParam Map<String, Object> data, HttpSession session, int total){
		log.debug("<<total>>"+total);
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		log.debug("<<ACTION!>> : "+data.get("data"));
		String test = (String)data.get("data");
		try {
			
			JSONArray array = JSONArray.fromObject(test);
			List<Map<String, String>> list = new ArrayList<Map<String,String>>();
			for(int i=0;i<array.size();i++) {
				JSONObject obj = (JSONObject)array.get(i);
				log.debug("<<fsjkdlkfjkals>> : "+obj);
				Map<String, String> re = new HashMap<String, String>();
				
				re.put("mem_cart_num", (String)obj.get("mem_cart_num"));
				re.put("used_product_num", (String)obj.get("used_product_num"));
				re.put("cart_quantity",(String)obj.get("cart_quantity"));
				re.put("store_product_num", (String)obj.get("store_product_num"));
				re.put("store_product_pricestandard", (String)obj.get("store_product_pricestandard"));
				
				list.add(re);
			}
			List<BookStorePaymentCartVO> cartList = new ArrayList<BookStorePaymentCartVO>();
			
			for(Map<String, String> map : list) {
				BookStorePaymentCartVO vo = new BookStorePaymentCartVO();
				if(map.get("mem_cart_num")!=null) {
				vo.setMem_cart_num(Integer.parseInt(map.get("mem_cart_num")));
				vo.setUsed_product_num(Integer.parseInt(map.get("used_product_num")));
				}
				vo.setCart_quantity(Integer.parseInt(map.get("cart_quantity")));
				vo.setStore_product_num(Integer.parseInt(map.get("store_product_num")));
				int price = Integer.parseInt(map.get("cart_quantity"))*Integer.parseInt(map.get("store_product_pricestandard").substring(0, map.get("store_product_pricestandard").length()-1));
				vo.setOrder_product_price(price);
				vo.setMem_num(mem_num);
				
				cartList.add(vo);
				log.debug("<<orderList>> : "+cartList);
				bookStorePaymentService.updateCart(vo);
			}
			mapJson.put("result", "success");
			session.setAttribute("cartList", cartList);
			session.setAttribute("total", total);
		} catch (Exception e) {  
			e.printStackTrace(); 
		}
		
		return mapJson;
	}
	
	//주문 페이지
	@GetMapping("/bookstore/payment/order.do")
	public String orderForm(HttpSession session, Model model) {
		log.debug("<<세션 확인 order >> : "+session.getAttribute("cartList"));
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			return "redirect:/lm/login/template/loginMain.do?lo=1";
		}		
		int mem_num = (Integer)session.getAttribute("mem_num");
		int count = 0;
		List<BookStorePaymentCartVO> list = (ArrayList)session.getAttribute("cartList");
		if(list == null) {//장바구니로 돌아가기
			return "redirect:/bookstore/payment/cart.do";
		}
		List<ProductVO> book_list = new ArrayList<ProductVO>();
		//회원 배송지 정보
		List<MemberVO> home_list = new ArrayList<MemberVO>();
		home_list = bookStorePaymentOrderService.selectMemHome(mem_num);
		//총 구매액
		int total = (int)session.getAttribute("total");
		for(BookStorePaymentCartVO vo : list) {
			ProductVO product = bookStorePaymentService.selectDetailBook(vo.getStore_product_num());
			log.debug("<<fjidslkjf>> : "+vo.getUsed_product_num());
			if(vo.getUsed_product_num() != 0) {//중고 상품 추가 정보
				UsedVO used = bookStorePaymentService.selectUsedBook(vo.getUsed_product_num());
				log.debug("<<도서 중고 정보>> : "+used);
				product.setUsed_product_price(used.getUsed_product_price());
				product.setUsed_product_status(used.getUsed_product_status());
				product.setUsed_product_num(used.getUsed_product_num());
			}
			book_list.add(product);
			count += vo.getCart_quantity();
		}
		
		MemberVO member = memberService.selectMember(mem_num);
		//배송정보
		MemberVO home = bookStorePaymentOrderService.selectDefaultHome(mem_num);
		//등급에 따른 포인트 정보
		double point = getPoint(member.getMem_grade());
		//상품 정보
		model.addAttribute("list", list);
		model.addAttribute("book_list", book_list);
		log.debug("<<주문페이지 확인-list>>"+list);
		log.debug("<<주문페이지 확인-book_list>>"+book_list);
		model.addAttribute("count", count);
		//금액 정보&회원 할인 정보
		model.addAttribute("total", total);
		model.addAttribute("mem", member);
		model.addAttribute("point", point);
		//회원 배송 정보
		model.addAttribute("home", home);
		log.debug("<<기본 배송지>> : "+home);	
		model.addAttribute("home_list", home_list);
		//log.debug("<<배송지 리스트>> : "+home_list);
		return "order";
	}
	//결제 검증
	@Value("${imp_key}")
	private String imp_key;
	@Value("${imp_secret}")
	private String imp_secret;

	@RestController
	@RequiredArgsConstructor
	@RequestMapping("/verifyIamport")
	private class VeriyController{
		private IamportClient api = new IamportClient(imp_key, imp_secret);
		
		@RequestMapping("/{imp_uid}")
		@ResponseBody
		public IamportResponse<Payment> paymentByUid(@PathVariable String imp_uid) throws IOException, IamportResponseException{
			log.debug("<<결제 검증>> : "+imp_uid);
			return api.paymentByImpUid(imp_uid);	
		}
	}
	
	//주문 성공시 주문 내역 저장
	@RequestMapping("/bookstore/payment/orderAction.do")
	@ResponseBody
	public Map<String, Object> payBook(String orderInfo, HttpSession session, String notice, int point) {
		log.debug("<<결제 데이터 확인>> : "+orderInfo);
		log.debug("<<배송시 요청사항>> : "+notice);
		int mem_num = (Integer)session.getAttribute("mem_num");		
		org.json.JSONObject jObject = new org.json.JSONObject(orderInfo);
		//boolean result = jObject.getBoolean("success");
		List<BookStorePaymentCartVO> list = (ArrayList)session.getAttribute("cartList");
		log.debug("<<주문완료 - cartList>> : "+list);
		BookStorePaymentOrderVO order = new BookStorePaymentOrderVO();
		//데이터 뽑기
		int total = (int)session.getAttribute("total");
		MemberVO mem_home = bookStorePaymentOrderService.selectDefaultHome(mem_num);
		order.setHome_num(mem_home.getHome_num());
		order.setMem_num(mem_home.getMem_num());
		order.setOrder_total_price(jObject.getInt("paid_amount"));
		order.setOrder_notice(notice);
		
		String type = jObject.getString("pg_provider");
		int payment_type = 1;
		if(type.equals("kakaopay")) {
			payment_type = 2;
		}
		order.setPayment_type(payment_type);
		order.setIMP_UID(jObject.getString("imp_uid"));
		log.debug("<<result-order>> : "+order);
		log.debug("<<result-cartList>> : "+list);
		//order 테이블 insert + 카트 정보 작세 + 재고 변경
		bookStorePaymentOrderService.insertOrder(order, list);
		
		//포인트 증감 - 회원 정보와 총금액
		Map<String, Object> map = new HashMap<String, Object>();
		MemberVO member = memberService.selectMember(mem_num);
		double grade = getPoint(member.getMem_grade());
		int addPoint = (int) Math.round(total*grade);//적립되는 포인트
		map.put("mem_num", mem_num);
		map.put("addPoint", (point*-1));//사용한 포인트
		map.put("order_num", order.getOrder_num());
		log.debug("<<포인트 - controller>> : "+map+','+addPoint);
		bookStorePaymentOrderService.updatePoint(map, addPoint);
		
		//세션 정보 삭제
		session.removeAttribute("cartList");
		session.removeAttribute("total");
		Map<String, Object> mapJson = new HashMap<String, Object>();
		
		mapJson.put("result", "success");
		mapJson.put("order", order);
		return mapJson;
	}

	//배송지 수정
	//폼
	@GetMapping("/bookstore/payment/homeModify.do")
	@ResponseBody
	public Map<String, Object> modifyForm(int home_num, HttpSession session){
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}
		MemberVO homeInfo = bookStorePaymentOrderService.selectHome(home_num);
		log.debug("<<배송 정보 수정>> : "+homeInfo);
		mapJson.put("homeInfo", homeInfo);
		mapJson.put("result", "success");
		return mapJson;
	}
	//동작
	@PostMapping("/bookstore/payment/homeModify.do")
	@ResponseBody
	public Map<String, Object> modifyAction(MemberVO memberVO, HttpSession session){
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		log.debug("<<수정 Action>> : "+memberVO);
		//기본 배송지로 설정한 주소 등록 시
		memberVO.setMem_num(mem_num);
		bookStorePaymentOrderService.updateHome(memberVO);
		if(memberVO.getHome_default() == 0) {
			mapJson.put("default", memberVO);
		}
		//회원 배송지 정보
		List<MemberVO> home_list = new ArrayList<MemberVO>();
		home_list = bookStorePaymentOrderService.selectMemHome(mem_num);
		log.debug("<<수정 ACTION - home_list>> : "+home_list);
		mapJson.put("result", "success");
		mapJson.put("home_list", home_list);
		return mapJson;
	}
	//배송지 등록
	@PostMapping("/bookstore/payment/homeInsert.do")
	@ResponseBody
	public Map<String, Object> insertHome(MemberVO memberVO, HttpSession session){
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		memberVO.setMem_num(mem_num);
		log.debug("<<배송 정보>> : "+memberVO);
		bookStorePaymentOrderService.insertHome(memberVO);
		//회원 배송지 정보
		List<MemberVO> home_list = new ArrayList<MemberVO>();
		home_list = bookStorePaymentOrderService.selectMemHome(mem_num);
		//기본 배송지로 설정한 주소 등록 시
		if(memberVO.getHome_default() == 0) {
			mapJson.put("default", memberVO);
		}
			
		mapJson.put("result", "success");
		mapJson.put("home_list", home_list);
		return mapJson;
	}
	//배송지 삭제
	@RequestMapping("/bookstore/payment/homeDelete.do")
	@ResponseBody
	public Map<String, Object> deleteHome(int home_num, HttpSession session, Model model) {
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
			return mapJson;
		}		
		int mem_num = (Integer)session.getAttribute("mem_num");
		bookStorePaymentOrderService.deleteHome(home_num);
		//회원 배송지 정보
		List<MemberVO> home_list = new ArrayList<MemberVO>();
		home_list = bookStorePaymentOrderService.selectMemHome(mem_num);
		mapJson.put("result", "success");
		mapJson.put("home_list", home_list);
		return mapJson;
	}
	//기본 배송지 업데이트
	@RequestMapping("/bookstore/payment/defaultChange.do")
	@ResponseBody
	public Map<String, Object> ChangeDefault(Integer home_num, HttpSession session){
		Map<String, Object> mapJson = new HashMap<String, Object>();
		String mem_id = (String)session.getAttribute("mem_id");
		if(mem_id == null) {
			mapJson.put("result", "logout");
		}
		int mem_num = (Integer)session.getAttribute("mem_num");
		MemberVO memberVO = memberService.selectMember(mem_num);
		memberVO.setMem_num(mem_num);
		bookStorePaymentOrderService.updateNormal(home_num, memberVO);
		//회원 배송지 정보
		List<MemberVO> home_list = new ArrayList<MemberVO>();
		home_list = bookStorePaymentOrderService.selectMemHome(mem_num);	
		log.debug("<<기본 배송지 업데이트>> : "+home_list);
		mapJson.put("result", "success");
		mapJson.put("home_list", home_list);
		return mapJson;
	}
	//영수증 페이지 보여주기
	@RequestMapping("/bookstore/payment/receipt.do")
	public String showReceipt(int order_num, HttpSession session, Model model) {
		log.debug("<<영수증 페이지>> : "+order_num);
		BookStorePaymentOrderVO order = bookStorePaymentOrderService.selectOrder(order_num);
		//책 정보
		List<BookStorePaymentOrderVO> list = bookStorePaymentOrderService.listOrder(order_num);
		String book_name = "";
		int product_num = list.get(0).getStore_product_num();
		ProductVO vo = bookStorePaymentOrderService.selectProductNum(product_num);
		if(list.size()>1) {
			int length = vo.getStore_product_title().length();
			int cut = 5;
			if( length <= 5) {
				cut = length-1;
			}
			book_name = vo.getStore_product_title().substring(0, cut)+"외 "+(list.size()-1)+"권";
		}else {
			book_name = vo.getStore_product_title();
		}
		MemberVO homeInfo = bookStorePaymentOrderService.selectHome(order.getHome_num());
		model.addAttribute("order", order);
		model.addAttribute("book_name", book_name);
		model.addAttribute("homeInfo", homeInfo);
		return "receipt";
	}

	//멤버 등급에 따른 포인드 % 가져오기
	public double getPoint(int grade) {
		double point = 0.005;
		if(grade == 1 ) point = 0.01;
		else if(grade == 2 ) point = 0.015;
		else if(grade == 3 ) point = 0.02;
		else if(grade == 4 ) point = 0.03;
		
		return point;
	}
}

@Service
@Transactional
public class ProductServiceImpl implements ProductService{
	@Autowired
	ProductMapper productMapper;
	
	@Override
	public ProductVO selectProduct(String store_product_isbn13) {
		return productMapper.selectProduct(store_product_isbn13);
	}

	@Override
	public List<ProductVO> selectList(Map<String, Object> map) {
		return productMapper.selectList(map);
	}

	@Override
	public int selectRowCount(Map<String, Object> map) {
		return productMapper.selectRowCount(map);
	}

	@Override
	public ProductFavVO selectFav(ProductFavVO fav) {
		return productMapper.selectFav(fav);
	}

	@Override
	public int selectFavCount(Integer store_product_num) {
		return productMapper.selectFavCount(store_product_num);
	}

	@Override
	public void insertFav(ProductFavVO fav) {
		productMapper.insertFav(fav);
	}

	@Override
	public void deleteFav(Integer ZZIM_NUM) {
		productMapper.deleteFav(ZZIM_NUM);
	}

	@Override
	public List<UsedVO> selectUsedNum(int store_product_num) {
		return productMapper.selectUsedNum(store_product_num);
	}
	
	@Override
	public List<ProductVO> selectBestBook() {
		return productMapper.selectBestBook();
	}

	@Override
	public List<ProductVO> selectNewBook() {
		return productMapper.selectNewBook();
	}

	@Override
	public List<ProductVO> selectFuture() {
		return productMapper.selectFuture();
	}

	@Override
	public List<ProductVO> selectCategoryBook(Map<String, Object> map) {
		return productMapper.selectCategoryBook(map);
	}

	@Override
	public int selectCategoryCount(Map<String, Object> map) {
		return productMapper.selectCategoryCount(map);
	}

	@Override
	public List<ProductVO> selectBestBookList(int start, int end) {
		List<ProductVO> list = productMapper.selectBestBookList(start, end);
		for(ProductVO vo : list) {
			if(vo.getStore_product_title().length()>=10) {
				String title = vo.getStore_product_title().substring(0, 10)+"...";
				vo.setStore_product_title(title);
			}
		}
		return productMapper.selectBestBookList(start, end);
	}

	@Override
	public List<ProductVO> selectCateTop3(String cate) {
		List<ProductVO> list = productMapper.selectCateTop3(cate);
		for(ProductVO vo : list) {
			if(vo.getStore_product_author().length()>=10) {
				String author = vo.getStore_product_author().substring(0, 10)+"...";
				vo.setStore_product_author(author);
			}
		}
		return list;
	}

	@Override
	public List<ProductVO> selectCateRandom(String cate) {
		return productMapper.selectCateRandom(cate);
	}

	@Override
	public List<ProductVO> selectCateNew(String cate) {
		List<ProductVO> list =  productMapper.selectCateNew(cate);
		for(ProductVO vo : list) {
			if(vo.getStore_product_author().length()>=10) {
				String author = vo.getStore_product_author().substring(0, 10)+"...";
				vo.setStore_product_author(author);
			}
		}
		return list;
	}

	@Override
	public List<ProductVO> selectNew(String cate) {
		List<ProductVO> list =  productMapper.selectNew(cate);
		for(ProductVO vo : list) {
			if(vo.getStore_product_title().length()>=10) {
				String title = vo.getStore_product_title().substring(0, 10)+"...";
				vo.setStore_product_title(title);
			}
		}
		return list;
	}


}

@Service
@Transactional
@Slf4j
public class BookStorePaymentServiceImpl implements BookStorePaymentService{
	//api 값 가져오기
	@Value("${imp_key}")
	private String imp_key;
	@Value("${imp_secret}")
	private String imp_secret;
	
	@Data
	private class Response{
		private PaymentInfo response;
	}
	@Data
	private class PaymentInfo{
		private int amount;
	}
	
	@Autowired
	BookStorePaymentCartMapper bookStorePaymentCartMapper;
	//카트 추가
	@Override
	public void insertCart(BookStorePaymentCartVO cartVO) {
		bookStorePaymentCartMapper.insertCart(cartVO);
	}
	//카트 정보
	@Override
	public List<BookStorePaymentCartVO> selectCartList(int mem_num) {
		return bookStorePaymentCartMapper.selectCartList(mem_num);
	}
	//중고도서 중복 확인
	@Override
	public BookStorePaymentCartVO selectEmptyUsed(int used_product_num, int mem_num) {
		return bookStorePaymentCartMapper.selectEmptyUsed(used_product_num, mem_num);
	}
	//도서 상세
	@Override
	public ProductVO selectDetailBook(int store_product_num) {
		return bookStorePaymentCartMapper.selectDetailBook(store_product_num);
	}
	//재고 변경
	@Override
	public void updateBookQuantity(int total, int mem_cart_num) {
		bookStorePaymentCartMapper.updateBookQuantity(total, mem_cart_num);
	}

	@Override
	public void updateCart(BookStorePaymentCartVO cartVO) {
		bookStorePaymentCartMapper.updateCart(cartVO);
	}

	
//토큰 값 받아오기
	@Override
	public String getToken() throws IOException {
		log.debug("<<KEY 값 : >>"+imp_key);
		log.debug("<<Secret 값 : >>"+imp_secret);
		
		BufferedWriter bw = null;
		BufferedReader br = null;
		String token = null;
		//REST API 호출에 사용
		HttpsURLConnection conn = null;

		try {
			//IOException 발생
			URL url = new URL("https://api.iamport.kr/users/getToken");//토큰 값을 받아오는 주소
			conn = (HttpsURLConnection) url.openConnection();
			conn.setRequestMethod("POST");
			conn.setRequestProperty("Content-type", "application/json");
			conn.setRequestProperty("Accept", "application/json");
			conn.setDoOutput(true);
			
			JsonObject json = new JsonObject(); //String 객체를 json 객체로 바꿔줄 때 사용한다 google.gson ~
			json.addProperty("imp_key", imp_key);
			json.addProperty("imp_secret", imp_secret);
			
			bw = new BufferedWriter(new OutputStreamWriter(conn.getOutputStream()));
			bw.write(json.toString());
			bw.flush();
			bw.close();
			br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"utf-8"));
			
			Gson gson = new Gson();//json 구조의 직렬화 된 데이터를 java 객체로 역직렬화 해주는 라이브러리 (직렬화도 해줌)
			//============추가로 설명 작성=====================//
			String response = gson.fromJson(br.readLine(), Map.class).get("response").toString();
			log.debug("<<getToken Method - response>> : "+response);//로그 확인
			//토큰 값 받기
			token = gson.fromJson(response, Map.class).get("access_token").toString();
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(bw != null)try {bw.close();} catch(IOException e) {}
			if(br != null)try {br.close();} catch(IOException e) {}
		}
		return token;
	}
	//결제 정보 가져오기
	@Override
	public int paymentInfo(String token, String IMP_UID) throws IOException {
		HttpURLConnection conn = null;
		URL url = new URL("https://api.iamport.kr/payments/"+IMP_UID);
		
		conn = (HttpURLConnection)url.openConnection();
		conn.setRequestMethod("GET");
		conn.setRequestProperty("Authorization", token);
		conn.setDoOutput(true);// OutputStream으로 POST 데이터를 넘겨주겠다는 옵션
		
		BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"utf-8"));
		Gson gson = new Gson();
		
		Response response = gson.fromJson(br.readLine(), Response.class);
		log.debug("<<response>> : "+response);
		
		br.close();
		conn.disconnect();
		
		return response.getResponse().getAmount();
	}

	//결제 취소하기
	@Override
	public void cancelPay(String token, String IMP_UID, int amount,String reason)throws IOException {
		log.debug("<<토큰 받기 성공!!>> : "+token);
		log.debug("<<주문 정보 가져오기 성공 !!>> : "+amount);
		
		HttpsURLConnection conn = null;
		URL url = new URL("https://api.iamport.kr/payments/cancel");//주문 취소 API주소 > io예외처리 
		conn = (HttpsURLConnection)url.openConnection(); //주소 연결
		
		conn.setRequestMethod("POST");
		conn.setRequestProperty("Content-type", "application/json");
		conn.setRequestProperty("Authorization", token);
		
		conn.setDoOutput(true);
		
		JsonObject json = new JsonObject();
		json.addProperty("reason", reason);
		json.addProperty("imp_uid", IMP_UID);
		json.addProperty("amount", amount);
		json.addProperty("checksum", amount);//가격 체크
		// Request Body에 Data를 담기위해 OutputStream 객체를 생성. // 데이터를 reqestbody에 담아서 서버로 보냄
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(conn.getOutputStream()));
		bw.write(json.toString());//버퍼에 있는 값 출력
		bw.flush();//남아있는 값 전부 출력
		bw.close();//스트림을 닫음
		//서버로 부터의 응답을 읽음
		BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"utf-8"));
		Gson gson = new Gson();//json 구조의 직렬화 된 데이터를 java 객체로 역직렬화 해주는 라이브러리 (직렬화도 해줌)
		//============추가로 설명 작성=====================//
		String response = gson.fromJson(br.readLine(), Map.class).get("response").toString();
		log.debug("<<결제 취소 응답>> : "+response);
		br.close();
		conn.disconnect();
	}

	@Override
	public UsedVO selectUsedBook(int used_product_num) {
		return bookStorePaymentCartMapper.selectUsedBook(used_product_num);
	}
	@Override
	public void deleteCart(int mem_cart_num) {
		bookStorePaymentCartMapper.deleteCart(mem_cart_num);
	}
}

@Service
@Slf4j
public class BookStorePaymentOrderServiceImpl implements BookStorePaymentOrderService{
	@Autowired
	BookStorePaymentOrderMapper bookStorePaymentOrderMapper;
	@Autowired
	BookStorePaymentCartMapper	bookStorePaymentCartMapper;
	@Autowired
	MemberService memberService;
	@Autowired 
	BsEventMapper bsEventMapper; //포인트 적립 관련
	@Autowired
	PointMapper pointMapper;
	//주문 테이블 저장
	@Override
	public void insertOrder(BookStorePaymentOrderVO bookStorePaymentOrderVO, List<BookStorePaymentCartVO> cartInfo) {
		int order_num = bookStorePaymentOrderMapper.selectOrder_num();
		
		bookStorePaymentOrderVO.setOrder_num(order_num);
		bookStorePaymentOrderMapper.insertOrder(bookStorePaymentOrderVO);
		
		for(BookStorePaymentCartVO vo : cartInfo) {
			log.debug("<<insert-detail>> : "+vo);
			vo.setOrder_num(order_num);
			//도서 상세 등록 후 해당 도서 장바구니에서 삭제
			bookStorePaymentOrderMapper.insertDetailOrder(vo);
			bookStorePaymentCartMapper.deleteCart(vo.getMem_cart_num());
			if(vo.getUsed_product_num() != 0) {
				bookStorePaymentOrderMapper.updateUsed(0,vo.getUsed_product_num());
				continue;
			}
			int quantity = vo.getCart_quantity()*-1;
			bookStorePaymentOrderMapper.updateProduct(vo.getStore_product_num(),quantity);
		}
	}
	

//배송지 관련
	@Override
	public MemberVO selectHome(int home_num) {
		return bookStorePaymentOrderMapper.selectHome(home_num);
	}

	@Override
	public List<MemberVO> selectMemHome(int mem_num) {
		return bookStorePaymentOrderMapper.selectMemHome(mem_num);
	}
//배송지 추가
	@Override
	public void insertHome(MemberVO memberVo) {
		if(memberVo.getHome_default() == 0) {
			MemberVO member = memberService.homeDefault(memberVo.getMem_num());
			log.debug("<<update home>> : "+member);
			bookStorePaymentOrderMapper.updateDefault(member);
		}
		bookStorePaymentOrderMapper.insertHome(memberVo);
	}
	@Override
	public void deleteHome(int home_num) {
		bookStorePaymentOrderMapper.deleteHome(home_num);;
	}
	@Override
	public MemberVO selectDefaultHome(int mem_num) {
		return bookStorePaymentOrderMapper.selectDefaultHome(mem_num);
	}
	@Override
	public void updateHome(MemberVO memberVO) {
		if(memberVO.getHome_default() == 0) {
			MemberVO member = memberService.homeDefault(memberVO.getMem_num());
			bookStorePaymentOrderMapper.updateDefault(member);
		}
		bookStorePaymentOrderMapper.updateHome(memberVO);
	}
	@Override
	public void updateNormal(int home_num, MemberVO mem) {
		bookStorePaymentOrderMapper.updateDefault(mem);
		bookStorePaymentOrderMapper.updateNormal(home_num);
	}
	@Override
	public BookStorePaymentOrderVO selectOrder(int order_num) {
		return bookStorePaymentOrderMapper.selectOrder(order_num);
	}
	@Override
	public List<BookStorePaymentOrderVO> listOrder(int order_num) {
		return bookStorePaymentOrderMapper.listOrder(order_num);
	}
	@Override
	public ProductVO selectProductNum(int product_num) {
		return bookStorePaymentOrderMapper.selectProductNum(product_num);
	}
	//==================주문 취소==========================//
	//imp_uid 값 구하기
	@Override
	public String selectImp_uid(int order_num) {
		return bookStorePaymentOrderMapper.selectImp_uid(order_num);
	}
	@Override
	public void updateCancelInfo(int order_num, String cancel_notice) {
		bookStorePaymentOrderMapper.updateCancelInfo(order_num, cancel_notice);
	}
	@Override
	public void updateQuantity(List<BookStorePaymentOrderVO> order) {
		log.debug("<<결제 취소 재고 변경>> : "+order);
		for(BookStorePaymentOrderVO vo : order) {
			if(vo.getUsed_product_num() != 0) {
				bookStorePaymentOrderMapper.updateUsed(1, vo.getUsed_product_num());
				continue;
			}
			int quantity = vo.getCart_quantity();
			bookStorePaymentOrderMapper.updateProduct(vo.getStore_product_num(),quantity);
		}
	}
	

	@Override
	public void updatePoint(Map<String, Object> map,int addPoint) {
		//포인트 차감 & 적립
		PointVO vo = new PointVO();
		vo.setMem_num((Integer)map.get("mem_num"));
		String order = String.valueOf(map.get("order_num"));
		vo.setPoint_reason(order);
		vo.setPoint_value((Integer)map.get("addPoint"));
		vo.setPoint_status(3);
		bsEventMapper.updateMemberPoint(map);
		//포인트 내역 등록
		pointMapper.insertOrderPoint(vo);
		log.debug("<<포인트 등록>> : "+vo);
		//적립 예정 포인트
		/*map.put("addPoint", addPoint);
		vo.setPoint_value((Integer)map.get("addPoint"));
		vo.setPoint_status(0);
		bsEventMapper.updateMemberPoint(map);
		pointMapper.insertOrderPoint(vo);*/
		//포인트 로그 등록
	}

	//주문 취소 포인트 조회
	@Override
	public void selectPoint(String point_reason) {
		//포인트 조회
		List<PointVO> point = pointMapper.selectPoint(point_reason);
		log.debug("<<주문 취소-포인트 조회>> : "+point);
		Map<String, Object> map = new HashMap<String, Object>();
		for(PointVO vo : point) {
			map.put("mem_num", vo.getMem_num());
			map.put("addPoint", (vo.getPoint_value()*-1));
			//내 포인트 변경
			bsEventMapper.updateMemberPoint(map);
		}
		//포인트 테이블 status 변경
		pointMapper.updatePointStatus(point_reason);
	}
}

@Mapper
public interface ProductMapper { 
	//알라딘 api에서 데이터 추출 후 db연동
	public void fetchData1FromApi();
	public void fetchData2FromApi(String isbn13);
	//api 상품 수정
	public void updateStore_P(ProductVO productVO);
	public void updateStore_Pdetail(ProductVO productVO);
	//책 번호 생성
	@Select("SELECT STORE_PRODUCT_MANAGE_seq.nextval FROM dual")
	public int selectStoreProductNum();	
	public void insertStore_P(ProductVO ProductVO);
	public void insertStore_Pdetail(ProductVO ProductVO);
	
	//상품리스트
	public List<ProductVO> selectList(Map<String,Object> map);
	public int selectRowCount(Map<String,Object> map);
	
	//상품 번호로 중고 상품 번호 리스트
	public List<UsedVO> selectUsedNum(int store_product_num);
	
	//상품 상세
	public ProductVO selectProduct(String store_product_isbn13);
	
	
	//좋아요
	@Select("SELECT * FROM STORE_MEMBER_ZZIM WHERE store_product_num=#{store_product_num} AND mem_num=#{mem_num}")
	public ProductFavVO selectFav(ProductFavVO fav);
	@Select("SELECT COUNT(*) FROM STORE_MEMBER_ZZIM WHERE store_product_num=#{store_product_num}")
	public int selectFavCount(Integer store_product_num);
	@Insert("INSERT INTO STORE_MEMBER_ZZIM (ZZIM_NUM,store_product_num,mem_num) VALUES (STORE_MEMBER_ZZIM_SEQ.nextval,#{store_product_num},#{mem_num})")
	public void insertFav(ProductFavVO fav);
	@Delete("DELETE FROM STORE_MEMBER_ZZIM WHERE ZZIM_NUM=#{ZZIM_NUM}")
	public void deleteFav(Integer ZZIM_NUM);
	@Delete("DELETE FROM STORE_MEMBER_ZZIM WHERE store_product_num=#{store_product_num}")
	public void deleteFavByProductNum(Integer store_product_num);	
	
	//메인 페이지
	//상품 댓글 수 & 평점 수 상위 5개 도서 뽑기
	@Select("SELECT * FROM( SELECT * FROM store_product_manage m JOIN store_product_detail USING(store_product_num) ORDER BY store_product_ratingCount DESC)  WHERE rownum >= 1 AND rownum <=5 ORDER BY store_product_ratingscore DESC")
	public List<ProductVO> selectBestBook();
	//신간 도서
	@Select("SELECT * FROM store_product_manage m JOIN store_product_detail USING(store_product_num) WHERE store_product_pubdate <= SYSDATE  AND rownum <=5 ORDER BY store_product_pubdate DESC")
	public List<ProductVO> selectNewBook();
	//출판 예정 도서
	@Select("SELECT * FROM (SELECT * FROM store_product_manage m JOIN store_product_detail USING(store_product_num) ORDER BY store_product_pubdate DESC) WHERE rownum <= 5")
	public List<ProductVO> selectFuture();
	
	//분야별 랜덤 도서 추천 5개
	public List<ProductVO> selectCateRandom(String cate);
	
	//카테고리 별 도서 검색
	public List<ProductVO> selectCategoryBook(Map<String, Object> map);
	//카데고리 별 도서 개수
	public int selectCategoryCount(Map<String, Object> map);
	//Best 도서
	public List<ProductVO> selectBestBookList(int start, int end);
	//분야별 TOP3
	public List<ProductVO> selectCateTop3(String cate);
	//분야별 신규도서
	public List<ProductVO> selectCateNew(String cate);
	//국내&외국도서 신규
	public List<ProductVO> selectNew(String cate);
	
}

@Mapper
public interface BookStorePaymentCartMapper {
	@Insert("insert into store_cart (mem_cart_num, mem_num, store_product_num, store_product_status, cart_quantity, used_product_num) values (em_cart_seq.nextval, #{mem_num}, #{store_product_num}, #{store_product_status},#{cart_quantity}, #{used_product_num})")
	public void insertCart(BookStorePaymentCartVO cartVO);
	
	@Select("select * from store_cart where mem_num = #{mem_num}")
	public List<BookStorePaymentCartVO> selectCartList(int mem_num);
	
	//도서 상세 정보
	public ProductVO selectDetailBook(int store_product_num);
	//중고 도서 정보
	@Select("SELECT * FROM store_used_product_detail d JOIN store_used_product_manage m USING(used_product_num) WHERE used_product_num = #{used_product_num}")
	public UsedVO selectUsedBook(int used_product_num);
	//카트 중고도서 중복확인
	@Select("SELECT * FROM store_cart WHERE used_product_num = #{used_product_num} AND mem_num = #{mem_num}")
	public BookStorePaymentCartVO selectEmptyUsed(int used_product_num,int mem_num);
	//중복 도서 합치기
	@Update("UPDATE store_cart SET cart_quantity = #{total} WHERE mem_cart_num = #{mem_cart_num}")
	public void updateBookQuantity(int total, int mem_cart_num);
	
	//주문 시 카트 변경사항 저장
	@Update("UPDATE store_cart SET cart_quantity = #{cart_quantity} WHERE mem_cart_num = #{mem_cart_num}")
	public void updateCart(BookStorePaymentCartVO cartVO);
	
	//장바구니에서 도서 삭제
	@Delete("DELETE FROM store_cart WHERE mem_cart_num = #{mem_cart_num}")
	public void deleteCart(int mem_cart_num);
}

@Mapper
public interface BookStorePaymentOrderMapper {
	//주문번호 생성
	@Select("SELECT store_order_manage_seq.nextval FROM dual")
	public int selectOrder_num();
	//주문 테이블 추가
	public void insertOrder(BookStorePaymentOrderVO bookStorePaymentOrderVO);
	public void insertDetailOrder(BookStorePaymentCartVO bookStorePaymentCartVO);
	
	//주문 정보
	@Select("SELECT * FROM store_order_manage WHERE order_num = #{order_num}")
	public BookStorePaymentOrderVO selectOrder(int order_num);
	//주문 상세 정보
	@Select("SELECT * FROM store_order_detail WHERE order_num = #{order_num}")
	public List<BookStorePaymentOrderVO> listOrder(int order_num);
	
	//배송 정보
	//home_num로 주소 찾기
	@Select("SELECT * FROM store_member_home WHERE home_num = #{home_num}")
	public MemberVO selectHome(int home_num);
	//회원 번호로 주소 찾기
	@Select("SELECT * FROM store_member_home WHERE mem_num = #{mem_num}")
	public List<MemberVO> selectMemHome(int mem_num);
	//회원의 기본 배송지 찾기
	@Select("SELECT * FROM store_member_home WHERE mem_num = #{mem_num} AND home_default = 0")
	public MemberVO selectDefaultHome(int mem_num);
	
	//주소 등록 하기
	@Insert("INSERT INTO store_member_home (home_num,mem_num,home_title,home_zipcode,home_address,home_address_detail,home_cell,home_name,home_default) VALUES (lm_member_manage_seq.nextval,#{mem_num},#{home_title},#{home_zipcode},#{home_address},#{home_address_detail},#{mem_cell},#{mem_name},#{home_default})")
	public void insertHome(MemberVO member);
	//기본 배송지 > 일반 변경
	@Update("UPDATE store_member_home SET home_default = 1 WHERE home_default = 0 AND mem_num = #{mem_num}")
	public void updateDefault(MemberVO memberVO);
	//일반 > 기본 배송지
	@Update("UPDATE store_member_home SET home_default = 0 WHERE home_num = #{home_num}")
	public void updateNormal(int home_num);
	//배송지 수정
	public void updateHome(MemberVO memberVO);
	
	//배송지 삭제
	@Delete("DELETE FROM store_member_home WHERE home_num = #{home_num}")
	public void deleteHome(int home_num);

	//도서 번호 검색
	@Select("SELECT * FROM store_product_detail WHERE store_product_num = #{product_num}")
	public ProductVO selectProductNum(int product_num);
	
	//주문 후 중고 status 값 바꾸기
	@Update("UPDATE store_used_product_manage SET used_product_status = #{num} WHERE used_product_num = #{used_product_num}")
	public void updateUsed(int num, int used_product_num);
	//구매 후 수량 변경
	@Update("UPDATE store_product_detail SET store_product_stock = store_product_stock+#{quantity} WHERE store_product_num = #{store_product_num}")
	public void updateProduct(int store_product_num, int quantity);	
	
	//주문 번호로 imp_uid를 가져오기
	@Select("SELECT imp_uid FROM store_order_manage WHERE order_num = #{order_num}")
	public String selectImp_uid(int order_num);
	//주문 취소후 주문상태와 취소 메시지 넣기
	@Update("UPDATE store_order_manage SET order_pay_status = 0,cancel_notice = #{cancel_notice} WHERE order_num = #{order_num}")
	public void updateCancelInfo(int order_num, String cancel_notice);
	
}