package escort.rest.user;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import escort.entity.*;
import escort.enums.CurrencyCode;
import escort.genericController.GenericAPIController;
import escort.repositoryDAO.*;
import escort.service.order.OrderService;
import escort.service.user.UserGoogleSender;
import escort.service.user.UserService;
import escort.util.DTOUtils;
import org.apache.commons.codec.digest.DigestUtils;
import org.codehaus.jackson.map.ObjectMapper;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

@RestController
@RequestMapping(value = "/escort/api")
public class UserController extends GenericAPIController<User, Long> {

    private static long TIME_FOR_SLEEP = 1000;
    private static final long TIME_FOR_DROP_CONNECTION = 50000;
    private static final long TIME_FOR_CHANGE_STATUS = 180000;

    @Autowired
    private UserGoogleSender userGoogleSender;

    @Autowired
    private UserTagsRepository userTagsRepository;

    @Autowired
    private OrderCustomerRepository orderCustomerRepository;

    @Autowired
    private OrderClientRepository orderClientRepository;

    @Autowired
    private InterestSettingsRepository interestSettingsRepository;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private MessageRepository messageRepository;

    @Autowired
    private PaymentEntityRepository paymentEntityRepository;

    @Autowired
    private TagRepository tagRepository;

    @Autowired
    private UserService userService;

    @Autowired
    private RateRepository rateRepository;

    @Autowired
    private PhotoRepository photoRepository;

    @Autowired
    private OrderService orderService;

    @Value("${repository.img}")
    private String pathToRepositoryImg;

    @Value("${domain.server}")
    private String domainServer;

    private HttpHeaders responseHeaders = new HttpHeaders();

    @RequestMapping(value = "/getPlaces", method = RequestMethod.GET, headers = {"Accept=application/json"})
    public String getPlaces(@RequestParam(value = "city") String city) throws UnsupportedEncodingException {
        return userGoogleSender.getPlaces(city);
    }

    @RequestMapping(value = "/getPlaceDetails", method = RequestMethod.GET, headers = {"Accept=application/json"})
    public String getPlacesDetails(@RequestParam(value = "placeId") String placeId) {
        return userGoogleSender.getPlacesDetails(placeId);
    }

    @RequestMapping(value = "/editProfile", method = RequestMethod.PUT, headers = {"Accept=application/json", "Content-Type=application/json"})
    public
    @ResponseBody
    @Transactional
    Object editProfile(@RequestBody UserDTO user) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String phone = auth.getPrincipal().toString();
        User currentUser = userRepository.findByPhone(phone);
        HashMap<String, String> userValid = userValidator(user);
        if (userValid.isEmpty()) {
            currentUser.setUserName(user.getUserName());
            currentUser.setCity(user.getCity());
            currentUser.setInvite(user.getInvite());
            currentUser.setAge(user.getAge());
            currentUser.setHairColor(user.getHairColor());
            currentUser.setHeight(user.getHeight());
            currentUser.setBodyType(user.getBodyType());
            currentUser.setTypeSexUser(user.getTypeSexUser());
            currentUser.setCityId(user.getCityId());
            currentUser.setPlaceId(user.getPlaceId());
            currentUser.setCurrencyCode(user.getCurrencyCode());

            userTagsRepository.deleteByUserId(currentUser.getId());


            //add new tags
            Set<UserTagsDTO> tagsSet = user.getUserTagsDTO();
            for (UserTagsDTO currentTag : tagsSet) {
                Tag tag = new Tag();
                UserTags ut = new UserTags();


                if (tagRepository.findByTagName(currentTag.getTagName().toLowerCase()) == null) { //new tag

                    tag.setName(currentTag.getTagName());
                    Tag newTag = (Tag) tagRepository.save(tag);

                    MyCompositePK myCompositePK = new MyCompositePK();

                    myCompositePK.setUserId(currentUser);
                    myCompositePK.setTagId(newTag);

                    ut.setId(myCompositePK);
                    ut.setDate(currentTag.getDate());
                    userTagsRepository.save(ut);

                } else { //tag exist
                    Tag t = tagRepository.findByTagName(currentTag.getTagName());
                    MyCompositePK myCompositePK = new MyCompositePK();

                    myCompositePK.setUserId(currentUser);
                    myCompositePK.setTagId(t);

                    ut.setId(myCompositePK);
                    ut.setDate(currentTag.getDate());
                    userTagsRepository.save(ut);
                }

            }

        } else {
            return new ResponseEntity<>(userValid, responseHeaders, HttpStatus.DESTINATION_LOCKED);
        }

        if (user.getAboutMe() != null) {
            currentUser.setAboutMe(user.getAboutMe());
        }
        //if "invited" has opened chats and he is going to be "inviter", we need to close all his chats
        if ((!currentUser.getInvite() || currentUser.getInvite() == null) && user.getInvite() == true) {
            //set non-archive messages of this user or received by this user to archive
            List<Message> listOfMessage = messageRepository.findNonArchiveMessagesSendReceivedByUser(currentUser.getId());
            if (!listOfMessage.isEmpty()) {
                for (Message messageCurrent : listOfMessage) {
                    messageCurrent.setArchive(true);
                    messageCurrent.setCreateDate(new Date().getTime());
                }
            }
        }
        if (!currentUser.getInvite() && user.getInvite()) {
            List<Message> allAvailableMessages = messageRepository.findAllAvailableMessages(currentUser.getId());
            for (Message currentMessage : allAvailableMessages) {
                currentMessage.setArchive(true);
                currentMessage.setRead(false);
                messageRepository.save(currentMessage);
            }
        }

        currentUser.setSmoker(user.getSmoker());

        if (user.getAvailable() != null) {
            currentUser.setAvailable(user.getAvailable());
        }
        if (user.getInterests() != null) {
            currentUser.setInterests(user.getInterests());
        }
        if (user.getOccupation() != null) {
            currentUser.setOccupation(user.getOccupation());
        }
        if (user.getLanguages() != null) {
            currentUser.setLanguages(user.getLanguages());
        }
        currentUser.setHairLength(user.getHairLength());
        save(currentUser);
        return new ResponseEntity<>("{\"result\":\"Edit success\"}", responseHeaders, HttpStatus.OK);
    }

    @RequestMapping(value = "/getUserInfoById/{id}", method = RequestMethod.PUT, headers = {"Content-Type=application/json"}, produces = {"application/json; charset=UTF-8"})
    public
    @ResponseBody
    Object getUserInfo(@PathVariable("id") Long id) {
        User currentUser = userRepository.findById(id);
        Set<UserTags> tagUser = userTagsRepository.findByUserId(id);
        currentUser.setUserTagses(tagUser);
        UserDTO userDTO = userService.processUserDTO(currentUser);
        if (currentUser.getAvatar() != null) {
            userDTO.setVerify(currentUser.getAvatar().getVerify());
            String avatar = domainServer + "/escort/api/repositoryImages/" + currentUser.getId() + "/" + currentUser.getAvatar().getComparePhotoName();
            String photo = domainServer + "/escort/api/repositoryImages/" + currentUser.getId() + "/" + currentUser.getAvatar().getPhotoName();
            userDTO.setAvatarFile(avatar);
            userDTO.setFullPhoto(photo);
        }

        currentUser.setUserTagses(tagUser);
        Set<UserTagsDTO> userTagsDTOSet = new HashSet<>();
        for (UserTags userTags :
                tagUser) {
            UserTagsDTO userTagsDTO = new UserTagsDTO();
            userTagsDTO.setTagName(tagRepository.findById(userTags.getId().getTagId().getId()).getName());
            userTagsDTO.setDate(userTags.getDate());
            userTagsDTOSet.add(userTagsDTO);
        }
        userDTO.setUserTagsDTO(userTagsDTOSet);
        Gson gson = new Gson();
        String jsonUser = gson.toJson(userDTO, UserDTO.class);
        if (jsonUser == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist currentUser\"}", responseHeaders, HttpStatus.OK);
        }


        Float averageRate = rateRepository.findAvergeRatingByUserId(currentUser.getId());
       /* List<Rate> comments = rateRepository.findAllCommentsOfUser(currentUser.getId());
        List<RateDTO> rateDTOList = new ArrayList<>();
        for(Rate currentRate : comments) {
            RateDTO rateDTO = new RateDTO();
            rateDTO.setIdReceiver(currentRate.getIdReceiver().getId());
            rateDTO.setId(currentRate.getId());
            rateDTO.setIdSender(currentRate.getIdSender().getId());
            rateDTO.setComment(currentRate.getComment());
            rateDTO.setRate(currentRate.getRate());
            rateDTOList.add(rateDTO);
        }*/
        JsonElement credJson = new JsonParser().parse(jsonUser);
//        String jsonRateDto = new Gson().toJson(rateDTOList);
        JsonElement averageRateJson = new JsonParser().parse(String.valueOf(averageRate));
//        JsonElement commentsJson = new JsonParser().parse(jsonRateDto);
        credJson.getAsJsonObject().remove("password");
        credJson.getAsJsonObject().add("averageRate", averageRateJson);
//        credJson.getAsJsonObject().add("comments", commentsJson);
        String result = credJson.getAsJsonObject().toString();
        return new ResponseEntity<>(result, responseHeaders, HttpStatus.OK);
    }

    @RequestMapping(value = "/getUserInfoByToken", method = RequestMethod.GET, produces = {"application/json; charset=UTF-8"})
    public
    @ResponseBody
    Object getUserInfoByToken() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String phone = auth.getPrincipal().toString();
        User userByToken = userRepository.findByPhone(phone);
        Set<UserTags> tags = userTagsRepository.findByUserId(userByToken.getId());
        userByToken.setUserTagses(tags);
        UserDTO userDTO = userService.processUserDTO(userByToken);
        Set<UserTagsDTO> userTagsDTOSet = new HashSet<>();
        for (UserTags userTags :
                tags) {
            UserTagsDTO userTagsDTO = new UserTagsDTO();
            userTagsDTO.setTagName(tagRepository.findById(userTags.getId().getTagId().getId()).getName());
            userTagsDTO.setDate(userTags.getDate());
            userTagsDTOSet.add(userTagsDTO);
        }
        if (userByToken.getCurrencyCode() != null) {
            userDTO.setCurrencyCode(userByToken.getCurrencyCode());
        }
        userDTO.setUserTagsDTO(userTagsDTOSet);
        if (userByToken.getAvatar() != null) {
            userDTO.setVerify(userByToken.getAvatar().getVerify());
            String avatar = domainServer + "/escort/api/repositoryImages/" + userByToken.getId() + "/" + userByToken.getAvatar().getComparePhotoName();
            String photo = domainServer + "/escort/api/repositoryImages/" + userByToken.getId() + "/" + userByToken.getAvatar().getPhotoName();
            userDTO.setAvatarFile(avatar);
            userDTO.setFullPhoto(photo);
        }
        userDTO.setBlocked(userByToken.getBlocked());
        userDTO.setPlaceId(userByToken.getPlaceId());
        userDTO.setCurrencyCode(userByToken.getCurrencyCode());

        Gson gson = new Gson();

        String jsonUser = gson.toJson(userDTO, UserDTO.class);
        if (jsonUser == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.OK);
        }
        Float averageRate = rateRepository.findAvergeRatingByUserId(userByToken.getId());
       /* List<Rate> comments = rateRepository.findAllCommentsOfUser(userByToken.getId());
        List<RateDTO> rateDTOList = new ArrayList<>();
        for(Rate currentRate : comments) {
            RateDTO rateDTO = new RateDTO();
            rateDTO.setIdReceiver(currentRate.getIdReceiver().getId());
            rateDTO.setId(currentRate.getId());
            rateDTO.setIdSender(currentRate.getIdSender().getId());
            rateDTO.setComment(currentRate.getComment());
            rateDTO.setRate(currentRate.getRate());
            rateDTOList.add(rateDTO);
        }*/
        JsonElement credJson = new JsonParser().parse(jsonUser);
        // String jsonRateDto = new Gson().toJson(rateDTOList);
        JsonElement averageRateJson = new JsonParser().parse(String.valueOf(averageRate));
        //JsonElement commentsJson = new JsonParser().parse(jsonRateDto);
        credJson.getAsJsonObject().remove("password");
        credJson.getAsJsonObject().add("averageRate", averageRateJson);
        //credJson.getAsJsonObject().add("comments", commentsJson);
        String result = credJson.getAsJsonObject().toString();
        return new ResponseEntity<>(result, responseHeaders, HttpStatus.OK);
    }

    @RequestMapping(value = "/editAccount", method = RequestMethod.PUT)
    public
    @ResponseBody
    Object editAccount(@RequestBody User user) {
        User userCurrent = read(user.getId());
        String password = user.getPassword();
        String email = user.getEmail();
        if (password != null) {
            userCurrent.setPassword(password);
        }
        if (email != null) {
            userCurrent.setEmail(email);
        }
        save(userCurrent);
        return "Change password";
    }

    @RequestMapping(value = "/changePassword", method = RequestMethod.PUT, headers = {"Content-Type=application/json"}, produces = {"application/json; charset=UTF-8"})
    public
    @ResponseBody
    Object changePassword(@RequestBody PendingOperation pendingUser) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String phone = auth.getPrincipal().toString();
        User user = userRepository.findByPhone(phone);
        if (user == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        String oldPassword = pendingUser.getOldPassword();
        if (oldPassword == null) {
            return new ResponseEntity<>("{\"result\":\"Old password is null\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        String sha1HexOldPassword = DigestUtils.sha1Hex(oldPassword.getBytes());
        String passwordCurrent = user.getPassword();
        if (!(passwordCurrent.equals(sha1HexOldPassword))) {
            return new ResponseEntity<>("{\"result\":\"The old password is incorrect\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        String newPassword = pendingUser.getPassword();
        if (newPassword == null) {
            return new ResponseEntity<>("{\"result\":\"Password is null\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        String sha1HexNewPassword = DigestUtils.sha1Hex(newPassword.getBytes());
        user.setPassword(sha1HexNewPassword);
        userRepository.save(user);
        return new ResponseEntity<>("{\"result\":\"Password change\"}", responseHeaders, HttpStatus.OK);
    }

    @RequestMapping(value = "/getChanges", method = RequestMethod.GET, produces = {"application/json; charset=UTF-8"})
    public
    @ResponseBody
    Object getChanges(@RequestParam Long timestamp) throws IOException {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String phone = auth.getPrincipal().toString();
        User currentUser = userRepository.findByPhone(phone);
        Long date = new Date().getTime();
        JSONObject response = new JSONObject();
        JSONObject result = new JSONObject();
        if (currentUser == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        if (!existNull(currentUser)) {
            return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.BAD_REQUEST);
        }
        long tempTime = 0;
        currentUser.setTimestamp(date);
        userRepository.save(currentUser);
        boolean flag = true;

        if (currentUser.getInvite()) {
            OrderCustomer orderCustomers = orderCustomerRepository.getOrderStatus(currentUser.getId());
            if (orderCustomers != null) {
                //Set<Tag> tags = new HashSet<>();
                //orderCustomers.getUser().setTags(tags);
                response.put("Order_Customer_Archive", orderCustomers.getArchive());
                result.put("Order_Customer_Archive", orderCustomers.getArchive());
            }
        }
        while (flag) {
            if (tempTime > TIME_FOR_DROP_CONNECTION) {
                flag = false;
            } else {
                try {

                    List<Message> messageList = messageRepository.findByIdSenderOrIdReceiverAndCreateDateLessThan(currentUser.getId(), timestamp);

                    List<OrderDTO> availableOrders = new ArrayList<>();

                    //JSONObject response = new JSONObject();

                    if (!currentUser.getInvite()) {

                        availableOrders = orderService.getNewOrdersForLady(currentUser, timestamp);
                        if (availableOrders != null) {
                            // availableOrders = orderService.getAvailableCustomersForLady(currentUser);
                            CurrencyCode currency = currentUser.getCurrencyCode();
                            for (OrderDTO orderDTO : availableOrders) {
                                String orderCurrency = userRepository.findUserCurrency(orderDTO.getUserId());
                                if (orderCurrency != null) {
                                    if (!orderCurrency.equals(currency.toString())) {
                                        Double price = orderDTO.getPrice() * userService.rate(orderCurrency.toLowerCase(), currency.toString().toLowerCase());
                                        double newPrice = new BigDecimal(price).setScale(3, RoundingMode.UP).doubleValue();
                                        orderDTO.setPrice(newPrice);
                                    }
                                }
                            }
                        }

                    } else {

                        availableOrders = orderService.getListOfAvailableOrdersForCustomer(currentUser, timestamp);

                    }
                    List<PaymentEntityDTO> payments = getPayments(currentUser, timestamp);
                    if (!messageList.isEmpty() || !payments.isEmpty()) {

                        if (!availableOrders.isEmpty()) {
                            response.put("availableOrders", availableOrders);
                        }
                        Collections.sort(messageList, (o1, o2) -> o1.getCreateDate().compareTo(o2.getCreateDate()));
                        List<MessageDataJsonDTO> messageListDto = DTOUtils.mapList(messageList, MessageDataJsonDTO.class);
                        TIME_FOR_SLEEP = 300;
                        if (!messageList.isEmpty()) {
                            response.put("messages", messageListDto);

                            List<ChatDTO> chatDTOList = getChatDTOs(currentUser, messageList);
                            if (!chatDTOList.isEmpty()) {
                                response.put("chats", chatDTOList);
                                response.put("new_chats", getLastChats(currentUser));
                            }
                        }

                        response.put("payments", payments);
                        // response.put("meet_confirm", meetConfirm);
                        addListStatusesAndTimestamp(currentUser, response, messageList);
                        response.put("timestamp", date);
                        response.put("blocked_user", currentUser.getBlocked());
                        response.put("new_chats", getLastChats(currentUser));
                        return response;
                    } else if (availableOrders != null && !availableOrders.isEmpty()) {

                        response.put("availableOrders", availableOrders);
                        response.put("timestamp", date);
                        response.put("blocked_user", currentUser.getBlocked());
                        // response.put("new_chats", getLastChats(currentUser));
                        return response;
                    } else {
                        response.put("new_chats", getLastChats(currentUser));
                        Thread.sleep(TIME_FOR_SLEEP);
                        tempTime += TIME_FOR_SLEEP;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        List<Message> messageList = new ArrayList<>();
        messageList.addAll(messageRepository.findByIdSenderOrIdReceiverAndCreateDateLessThan(currentUser.getId()));
        //JSONObject result = new JSONObject();

        if (!messageList.isEmpty()) {
            addListStatusesAndTimestamp(currentUser, result, messageList);
        } else {
            result.put("timestamp", date);
            result.put("blocked_user", currentUser.getBlocked());
        }
        return result;
    }

    @RequestMapping(value = "/getIndex", method = RequestMethod.GET, produces = {"application/json; charset=UTF-8"})
    public
    @ResponseBody
    Object getIndex() throws IOException {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String phone = auth.getPrincipal().toString();
        User userByToken = userRepository.findByPhone(phone);
        if (userByToken == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        Double index = indexForCustomer();
        return new ResponseEntity<>(index, responseHeaders, HttpStatus.OK);
    }

    //@RequestMapping(value = "/getChanges", method = RequestMethod.GET, produces = {"application/json; charset=UTF-8"})
//public
//@ResponseBody
//Object getChanges(@RequestParam Long timestamp) {
//    Authentication auth = SecurityContextHolder.getContext().getAuthentication();
//    String phone = auth.getPrincipal().toString();
//    User currentUser = userRepository.findByPhone(phone);
//    Long date = new Date().getTime();
//    if (currentUser == null) {
//        return new ResponseEntity<>("{\"result\":\"Does not exist user\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
//    }
//    long tempTime = 0;
//    currentUser.setTimestamp(new Date().getTime());
//    userRepository.save(currentUser);
//    boolean flag = true;
//
//    while (flag) {
//        if (tempTime > TIME_FOR_DROP_CONNECTION) {
//            flag = false;
//        } else {
//            try {
//
//                List<Message> messageList = messageRepository.findByIdSenderOrIdReceiverAndCreateDateLessThan(currentUser.getId(), timestamp);
//
//                List<OrderDTO> availableOrders = new ArrayList<>();
//
//                JSONObject response = new JSONObject();
//
//                if (!currentUser.getInvite()) {
//
//                    availableOrders = orderService.getNewOrdersForLady(currentUser, timestamp);
//                } else {
//
//                    availableOrders = orderService.getListOfAvailableOrdersForCustomer(currentUser, timestamp);
//                }
//                List<PaymentEntityDTO> payments = getPayments(currentUser, timestamp);
//                if (!messageList.isEmpty() || !payments.isEmpty() ) {
//
//                    if (!availableOrders.isEmpty()) {
//                        response.put("availableOrders", availableOrders);
//                    }
//                    Collections.sort(messageList, (o1, o2) -> o1.getCreateDate().compareTo(o2.getCreateDate()));
//                    List<MessageDataJsonDTO> messageListDto = DTOUtils.mapList(messageList, MessageDataJsonDTO.class);
//                    TIME_FOR_SLEEP = 300;
//                    if (!messageList.isEmpty()) {
//                        response.put("messages", messageListDto);
//
//                        List<ChatDTO> chatDTOList = getChatDTOs(currentUser, messageList);
//                        response.put("chats", chatDTOList);
//                        response.put("new_chats", getLastChats(currentUser));
//
//                    }
//
//                    response.put("payments", payments);
//
//                    addListStatusesAndTimestamp(currentUser, response, messageList);
//                    response.put("timestamp", new Date().getTime());
//                    response.put("blocked_user", currentUser.getBlocked());
//                    response.put("new_chats", getLastChats(currentUser));
//                    return response;
//                } else if (availableOrders != null && !availableOrders.isEmpty()) {
//
//                    response.put("availableOrders", availableOrders);
//                    response.put("timestamp", new Date().getTime());
//                    response.put("blocked_user", currentUser.getBlocked());
//                    response.put("new_chats", getLastChats(currentUser));
//                    return response;
//                } else {
//                    Thread.sleep(TIME_FOR_SLEEP);
//                    tempTime += TIME_FOR_SLEEP;
//                }
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        }
//    }
//    List<Message> messageList = new ArrayList<>();
//    messageList.addAll(messageRepository.findByIdSenderOrIdReceiverAndCreateDateLessThan(currentUser.getId()));
//    JSONObject result = new JSONObject();
//
//    if (!messageList.isEmpty()) {
//        addListStatusesAndTimestamp(currentUser, result, messageList);
//    } else {
//        result.put("timestamp", new Date().getTime());
//        result.put("blocked_user", currentUser.getBlocked());
//
//    }
//    return result;
//}
    private Object authorizeAndReturn(Object returnEntity) {
        User user = userService.getUserFromAuth();
        if (user == null) {
            return new ResponseEntity<>("{\"result\":\"Does not exist phone\"}", responseHeaders, HttpStatus.UNAUTHORIZED);
        }
        return returnEntity;
    }

    private List<PaymentEntityDTO> getPayments(User currentUser, Long timestamp) {

        List<PaymentEntity> payments = paymentEntityRepository.findNewPayments(currentUser.getId(), timestamp);
        List<PaymentEntityDTO> resultPayments = new ArrayList<>();

        if (payments != null) {
            for (PaymentEntity paymentEntity : payments) {

                PaymentEntityDTO newPayment = new PaymentEntityDTO();
                if (currentUser.getInvite()) {
                    newPayment.setReceiverId(paymentEntity.getReceiverId());
                    newPayment.setUserId(currentUser.getId());
                } else {
                    newPayment.setUserId(paymentEntity.getUser().getId());
                    newPayment.setReceiverId(currentUser.getId());
                }

                newPayment.setCurrency(paymentEntity.getCurrency());
                newPayment.setAmount(paymentEntity.getAmount());
                newPayment.setId(paymentEntity.getId());
                newPayment.setTransactionStatus(paymentEntity.getTransactionStatus());
                newPayment.setChargeId(paymentEntity.getChargeId());
                newPayment.setToken(paymentEntity.getToken());
                newPayment.setProvider(paymentEntity.getProvider());
                newPayment.setOrderId(paymentEntity.getOrderId());
                newPayment.setPaymentDate(paymentEntity.getPaymentDate());
                newPayment.setPayerId(paymentEntity.getPayerId());
                newPayment.setCardCryptogram(paymentEntity.getCardCryptogram());
                OrderClient orderClient = orderClientRepository.findById(paymentEntity.getOrderId(), paymentEntity.getReceiverId());
                if (orderClient != null) {
                    newPayment.setMeetConfirmClient(orderClient.getMeetConfirmedClient());
                    newPayment.setMeetConfirmCustomer(orderClient.getMeetConfirmedCustomer());
                }
                resultPayments.add(newPayment);
            }
        }
        return resultPayments;
    }

    private List<ChatDTO> getChatDTOs(User currentUser, List<Message> messageList) {

        Set<Long> otherUsers = getOtherUsers(currentUser, messageList);
        ArrayList<ChatDTO> chatDTOList = new ArrayList();

        for (Long userId : otherUsers) {

            ChatDTO chatDTO = new ChatDTO();
            User userById = this.userRepository.findById(userId);

            chatDTO.setId(userId);
            chatDTO.setUserName(userById.getUserName());
            if (userById.getAvatar() != null) {
                chatDTO.setAvatar(userById.getAvatarFile());
                chatDTO.setIsVerify(userById.getAvatar().getVerify());
            }
            Long numberOfMessages = messageRepository.findNewChatsOfUser(currentUser.getId(), userId);

            if (numberOfMessages == 1) {
                chatDTO.setNew(Boolean.TRUE);
            } else {
                chatDTO.setNew(Boolean.FALSE);
            }

            Message lastMessage = messageRepository.findChatsInArchiveForUser(currentUser.getId(), userId);
            if (lastMessage != null) {
                if (lastMessage.getArchive()) {
                    chatDTO.setArchive(Boolean.TRUE);
                } else {
                    chatDTO.setArchive(Boolean.FALSE);
                }

                chatDTOList.add(chatDTO);
            }
        }
        return chatDTOList;
    }

    private Set<Long> getOtherUsers(User currentUser, List<Message> messageList) {

        Set<Long> userListId = new HashSet<>();
        for (Message message : messageList) {
            if (!Objects.equals(message.getIdReceiver(), currentUser.getId())) {
                userListId.add(message.getIdReceiver());
            } else if (message.getIdSender() != currentUser.getId()) {
                userListId.add(message.getIdSender());
            }
        }
        return userListId;
    }

    private void addListStatusesAndTimestamp(User currentUser, JSONObject response, List<Message> messageList) {

        Set<Long> userListId = getOtherUsers(currentUser, messageList);

        response.put("statuses", getCurrentStatus(userListId));
        response.put("timestamp", new Date().getTime());
        response.put("blocked_user", currentUser.getBlocked());
        if (currentUser.getInvite()) {
            OrderCustomer orderCustomers = orderCustomerRepository.getOrderStatus(currentUser.getId());
            if (orderCustomers != null) {
                //Set<Tag> tags = new HashSet<>();
                //orderCustomers.getUser().setTags(tags);
                response.put("Order_Customer_Archive", orderCustomers.getArchive());
            }
        }


    }

    private JSONArray getCurrentStatus(Set<Long> listUserId) {
        JSONArray jsonArray = new JSONArray();
        if (listUserId.isEmpty()) {
            return jsonArray;
        }
        List<User> userList = userRepository.findUsersByListId(listUserId);
        for (User currentUser : userList) {
            JSONObject jsonObject = new JSONObject();
            if (currentUser.getTimestamp() != null) {
                if (new Date().getTime() - currentUser.getTimestamp() > TIME_FOR_CHANGE_STATUS) {
                    jsonObject.put("id", currentUser.getId());
                    jsonObject.put("status", false);
                } else {
                    jsonObject.put("id", currentUser.getId());
                    jsonObject.put("status", true);
                }
                jsonArray.add(jsonObject);
            }
        }
        return jsonArray;
    }

    @Override
    protected AdminBaseRepository<User, Long> getCrudRepository() {
        return userRepository;
    }

    public Object getChats(User user) {
        String resultJson = null;
        List<MessageDTO> result = new ArrayList<>();
        try {
            List<Message> allMessagesByLastDate = messageRepository.findByQuery(user.getId());
            Map<Long, Message> map = new HashMap<>();
            for (Message message : allMessagesByLastDate) {
                if (user.getId().equals(message.getIdReceiver())) {
                    map.put(message.getIdSender(), message);
                } else {
                    map.put(message.getIdReceiver(), message);
                }
            }

            for (Map.Entry<Long, Message> entry : map.entrySet()) {
                MessageDTO messageDTO = new MessageDTO();
                Long id = entry.getKey();
                Message message = entry.getValue();
                messageDTO.setId(id);
                messageDTO.setText(message.getText());
                messageDTO.setCreateDate(message.getCreateDate());
                User userById = userRepository.findById(id);
                messageDTO.setAvatar(userById.getAvatarFile());
                messageDTO.setAge(userById.getAge());
                messageDTO.setUserName(userById.getUserName());
                messageDTO.setRead(message.getRead());
                if (userById.getTimestamp() != null) {
                    if (new Date().getTime() - userById.getTimestamp() > TIME_FOR_CHANGE_STATUS) {

                        messageDTO.setStatus("false");
                    } else {

                        messageDTO.setStatus("true");
                    }

                }

                result.add(messageDTO);
            }
            Collections.sort(result, (o1, o2) -> o2.getCreateDate().compareTo(o1.getCreateDate()));
            resultJson = new ObjectMapper().writeValueAsString(result);


        } catch (IOException e) {
            e.printStackTrace();
        }

        return result;
    }

    public Object getLastChats(User user) {
        String resultJson = null;
        List<MessageDTO> result = new ArrayList<>();
        try {
            //List<Message> allMessagesByLastDate = messageRepository.findReadMessage(user.getId(), new Date().getTime());
            //List<Message> allMessagesByLastDate = messageRepository.findLastMessagesByChat(user.getId(), new Date().getTime());
            //
            List<Message> allMessagesByLastDate = messageRepository.findLastMessagesByEveryChatOfUser(user.getId());
            Map<Long, Message> map = new HashMap<>();
            for (Message message : allMessagesByLastDate) {
                if (user.getId().equals(message.getIdReceiver())) {
                    map.put(message.getIdSender(), message);
                } else {
                    map.put(message.getIdReceiver(), message);
                }
            }

            for (Map.Entry<Long, Message> entry : map.entrySet()) {
                MessageDTO messageDTO = new MessageDTO();
                Long id = entry.getKey();
                Message message = entry.getValue();
                messageDTO.setId(id);
                messageDTO.setText(message.getText());
                messageDTO.setCreateDate(message.getCreateDate());
                User userById = userRepository.findById(id);
                if (userById.getAvatar() != null) {
                    messageDTO.setAvatar(userById.getAvatarFile());
                    messageDTO.setIsVerify(userById.getAvatar().getVerify());
                }
                messageDTO.setAge(userById.getAge());
                messageDTO.setUserName(userById.getUserName());
                messageDTO.setRead(message.getRead());
                messageDTO.setArchive(message.getArchive());
                if (userById.getTimestamp() != null) {
                    if (new Date().getTime() - userById.getTimestamp() > TIME_FOR_CHANGE_STATUS) {

                        messageDTO.setStatus("false");
                    } else {

                        messageDTO.setStatus("true");
                    }

                }

                result.add(messageDTO);
            }
            Collections.sort(result, (o1, o2) -> o2.getCreateDate().compareTo(o1.getCreateDate()));
            resultJson = new ObjectMapper().writeValueAsString(result);


        } catch (IOException e) {
            e.printStackTrace();
        }

        return result;
    }


/* moved to user service
public Double rate(String from, String to) throws IOException {
        HttpClient httpClient = new HttpClient();
        GetMethod getMethod = new GetMethod("http://quote.yahoo.com/d/quotes.csv?s=" + from + to + "=X&f=l1&e=.csv");
        httpClient.executeMethod(getMethod);
        String results = getMethod.getResponseBodyAsString();
        Double response = Double.parseDouble(results);
        return response;
    }*/


    private Double indexForCustomer() {
        return interestSettingsRepository.findInd().getIndex();
    }

    private String getCityIdFromGoogle(String city) {

        return "";
    }

    private String getPlaceIdFromGoogle(String city) {
        return "";
    }

    private boolean existNull(User user) {
        if (user.getUserName() == null) {
            return false;
        } else if (user.getAge() == null) {
            return false;
        } else if (user.getAvailable() == null) {
            return false;
        } else if (user.getBodyType() == null) {
            return false;
        } else if (user.getCity() == null) {
            return false;
        } else if (user.getHairColor() == null) {
            return false;
        } else if (user.getHeight() == null) {
            return false;
        } else if (user.getInvite() == null) {
            return false;
        } else if (user.getTypeSexUser() == null) {
            return false;
        } else if (user.getAboutMe() == null) {
            return false;
        }
        return true;
    }

    private HashMap<String, String> userValidator(UserDTO user) {
        HashMap<String, String> userValid = new HashMap<>();
        if (user.getUserName() == null || user.getUserName().equals("")) {
            userValid.put("userName", "Does not exist");
        }
        if (user.getCityId() == null || user.getCityId().equals("")) {
            userValid.put("cityId", "Does not exist");
        }
        if (user.getCity() == null || user.getCity().equals("")) {
            userValid.put("city", "Does not exist");
        }
        if (user.getPlaceId() == null || user.getPlaceId().equals("")) {
            userValid.put("placeId", "Does not exist");
        }
        if (user.getInvite() == null || user.getInvite().equals("")) {
            userValid.put("invite", "Does not exist");
        }
        if (user.getAge() == null || user.getAge().equals("")) {
            userValid.put("age", "Does not exist");
        }
        if (user.getHairColor() == null || user.getHairColor().equals("")) {
            userValid.put("hairColor", "Does not exist");
        }
        if (user.getHeight() == null || user.getHeight().equals("")) {
            userValid.put("height", "Does not exist");
        }
        if (user.getBodyType() == null || user.getBodyType().equals("")) {
            userValid.put("bodyType", "Does not exist");
        }
        if (user.getTypeSexUser() == null || user.getTypeSexUser().equals("")) {
            userValid.put("typeSexUser", "Does not exist");
        }
        if (user.getCurrencyCode() == null || user.getCurrencyCode().equals("")) {
            userValid.put("currencyCode", "Does not exist");
        }
        if (user.getUserTagsDTO() == null) {
            userValid.put("userTagsDTO", "Does not exist");
        }
        return userValid;
    }

}