package com.qxgmat.controller.admin;

import com.github.pagehelper.Page;
import com.nuliji.tools.*;
import com.qxgmat.data.constants.enums.ServiceKey;
import com.qxgmat.data.constants.enums.module.FeedbackModule;
import com.qxgmat.data.constants.enums.module.ProductType;
import com.qxgmat.data.constants.enums.status.DirectionStatus;
import com.qxgmat.data.constants.enums.status.FeedbackStatus;
import com.qxgmat.data.constants.enums.user.MoneyRange;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.data.relation.entity.UserPreviewPaperRelation;
import com.qxgmat.dto.admin.extend.*;
import com.qxgmat.dto.admin.request.UserCourseAppointmentDto;
import com.qxgmat.dto.admin.request.UserFeedbackErrorDto;
import com.qxgmat.dto.admin.request.UserInvoiceDto;
import com.qxgmat.dto.admin.request.UserServiceRecordDto;
import com.qxgmat.dto.admin.response.*;
import com.qxgmat.help.ShiroHelp;
import com.qxgmat.service.ManagerService;
import com.qxgmat.service.UserPaperService;
import com.qxgmat.service.UserServiceService;
import com.qxgmat.service.extend.PreviewService;
import com.qxgmat.service.UsersService;
import com.qxgmat.service.inline.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.*;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;

@RestController("AdminUserController")
@RequestMapping("/admin/user")
@Api(tags = "用户接口", description = "用户相关操作", produces = MediaType.APPLICATION_JSON_VALUE)
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    @Autowired
    private ShiroHelp shiroHelp;

    @Autowired
    private ManagerLogService managerLogService;

    @Autowired
    private QuestionService questionService;

    @Autowired
    private QuestionNoService questionNoService;

    @Autowired
    private UsersService usersService;

    @Autowired
    private UserServiceService userServiceService;

    @Autowired
    private UserCourseService userCourseService;

    @Autowired
    private UserPaperService userPaperService;

    @Autowired
    private UserReportService userReportService;

    @Autowired
    private UserOrderService userOrderService;

    @Autowired
    private ManagerService managerService;

    @Autowired
    private PreviewService previewService;

    @Autowired
    private PreviewPaperService previewPaperService;

    @Autowired
    private UserCourseAppointmentService userCourseAppointmentService;

    @Autowired
    private UserFeedbackErrorService userFeedbackErrorService;

    @Autowired
    private UserOrderRecordService userOrderRecordService;

    @Autowired
    private UserInvoiceService userInvoiceService;

//    @RequestMapping(value = "/add", method = RequestMethod.POST)
//    @ApiOperation(value = "添加用户信息", httpMethod = "POST")
//    public Response<User> add(@RequestBody @Validated UserDto dto, HttpServletRequest request) {
//        User entity = Transform.dtoToEntity(dto);
//        entity = userService.edit(entity);
//        managerLogService.log(request);
//        return ResponseHelp.success(Transform.convert(entity, UserDto.class));
//    }
//    @RequestMapping(value = "/edit", method = RequestMethod.PUT)
//    @ApiOperation(value = "修改用户信息", httpMethod = "PUT")
//    public Response<Boolean> edit(@RequestBody @Validated UserDto dto, HttpServletRequest request) {
//        User entity = Transform.dtoToEntity(dto);
//        entity = userService.edit(entity);
//        managerLogService.log(request);
//        return ResponseHelp.success(true);
//    }
//
//    @RequestMapping(value = "/delete", method = RequestMethod.DELETE)
//    @ApiOperation(value = "删除用户", httpMethod = "DELETE")
//    public Response<Boolean> delete(@RequestParam int id, HttpServletRequest request) {
//        managerLogService.log(request);
//        return ResponseHelp.success(userService.delete(id));
//    }
    @RequestMapping(value = "/token", method = RequestMethod.GET)
    @ApiOperation(value = "获取用户token", httpMethod = "GET")
    public Response<String> token(@RequestParam int id, HttpSession session) {
        User entity = usersService.get(id);
        String token = usersService.getTokenByUser(entity);

        return ResponseHelp.success(token);
    }

    @RequestMapping(value = "/detail", method = RequestMethod.GET)
    @ApiOperation(value = "获取用户", httpMethod = "GET")
    public Response<UserDetailDto> detail(@RequestParam int id, HttpSession session) {
        User entity = usersService.get(id);
        UserDetailDto dto = Transform.convert(entity, UserDetailDto.class);


        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ApiOperation(value = "用户列表", httpMethod = "GET")
    public Response<PageMessage<UserListDto>> list(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false, defaultValue = "") String keyword,
            @RequestParam(required = false) Integer[] ids,
            @RequestParam(required = false) Boolean real,
            @RequestParam(required = false) String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<User> p;
        if (ids != null && ids.length > 0){
            p = usersService.select(ids);
        }else{
            p = usersService.select(page, size, keyword, real, order, DirectionStatus.ValueOf(direction));
        }
        List<UserListDto> pr = Transform.convert(p, UserListDto.class);

        Collection userIds = Transform.getIds(p, User.class, "id");
        // 绑定用户服务
        Map<Object, Collection<UserService>> serviceByUser = userServiceService.mapByUser(userIds);
        Transform.combine(pr, serviceByUser, UserListDto.class, "id", "services", UserServiceExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/student/list", method = RequestMethod.GET)
    @ApiOperation(value = "会员列表", httpMethod = "GET")
    public Response<PageMessage<UserListDto>> members(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false, defaultValue = "") String keyword,
            @RequestParam(required = false) Integer courseId,
            @RequestParam(required = false) String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        // 已经购买过课程的用户
        Page<User> p = usersService.listByCourse(page, size, keyword, courseId);
        List<UserListDto> pr = Transform.convert(p, UserListDto.class);

        Collection userIds = Transform.getIds(p, User.class, "id");

        // 绑定用户课程
        Map<Object, Collection<UserCourse>> courseByUser = userCourseService.mapByUser(userIds, false);
        Transform.combine(pr, courseByUser, UserListDto.class, "id", "classes", UserCourseExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/order/list", method = RequestMethod.GET)
    @ApiOperation(value = "用户订单列表", httpMethod = "GET")
    public Response<PageMessage<UserListDto>> listOrder(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserOrder> p = userOrderService.select(page, size);
        List<UserListDto> pr = Transform.convert(p, UserListDto.class);

        Collection userIds = Transform.getIds(p, User.class, "id");
        // 绑定用户服务
        Map<Object, Collection<UserService>> serviceByUser = userServiceService.mapByUser(userIds);
        Transform.combine(pr, serviceByUser, UserListDto.class, "id", "services", UserServiceExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/preview/list", method = RequestMethod.GET)
    @ApiOperation(value = "预习作业列表", httpMethod = "GET")
    public Response<PageMessage<UserPreviewListDto>> list(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false, defaultValue = "0") int category,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer previewId,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            HttpSession session) {
        PageResult<UserPreviewPaperRelation> p = previewService.listAdmin(page, size, category, userId, previewId, startTime, endTime);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserPreviewPaperRelation.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(p, userList, UserPreviewPaperRelation.class, "userId", "user", User.class, "id");

        // 绑定预习作业
        Collection previewIds = Transform.getIds(p, UserPreviewPaperRelation.class, "moduleId");
        List<PreviewPaper> previewPaperList = previewPaperService.select(previewIds);
        Transform.combine(p, previewPaperList, UserPreviewPaperRelation.class, "moduleId", "preview", PreviewPaper.class, "id");

        List<UserPreviewListDto> pr = Transform.convert(p, UserPreviewListDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/feedback_error/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "修改勘误信息", httpMethod = "PUT")
    public Response<Boolean> editFeedbackError(@RequestBody @Validated UserFeedbackErrorDto dto, HttpServletRequest request) {
        UserFeedbackError entity = Transform.dtoToEntity(dto);
        UserFeedbackError in = userFeedbackErrorService.get(entity.getId());

        // 处理设定
        if(in.getHandleTime() == null){
            entity.setHandleTime(new Date());
            Manager manager = shiroHelp.getLoginManager();
            entity.setManagerId(manager.getId());
        }

        entity = userFeedbackErrorService.edit(entity);

        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/feedback_error/detail", method = RequestMethod.GET)
    @ApiOperation(value = "勘误详情", httpMethod = "GET")
    public Response<UserFeedbackErrorInfoDto> detailFeedbackError(@RequestParam int id, HttpServletRequest request) {
        UserFeedbackError entity = userFeedbackErrorService.get(id);
        UserFeedbackErrorInfoDto dto = Transform.convert(entity, UserFeedbackErrorInfoDto.class);
        User user = usersService.get(entity.getUserId());
        UserExtendDto userDto = Transform.convert(user, UserExtendDto.class);
        dto.setUser(userDto);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/feedback_error/list", method = RequestMethod.GET)
    @ApiOperation(value = "勘误列表", httpMethod = "GET")
    public Response<PageMessage<UserFeedbackErrorInfoDto>> listFeedbackError(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) Integer moneyRang,
            HttpSession session) {
        Page<UserFeedbackError> p = userFeedbackErrorService.listAdmin(page, size, FeedbackModule.ValueOf(module), FeedbackStatus.ValueOf(status), keyword, userId, MoneyRange.ValueOf(moneyRang));
        List<UserFeedbackErrorInfoDto> pr = Transform.convert(p, UserFeedbackErrorInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserFeedbackError.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserFeedbackErrorInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/service/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加服务记录", httpMethod = "POST")
    private Response<Boolean> addService(@RequestBody @Validated UserServiceRecordDto dto){
        UserOrderRecord entity = Transform.dtoToEntity(dto);
        entity.setProductType(ProductType.SERVICE.key);
        entity.setOrderId(0);
        entity.setProductId(0);
        if (dto.getMobile() != null && !dto.getMobile().isEmpty()){
            // 判断mobile
            User user = usersService.getByMobile(dto.getMobile());
            if (user == null){
                // 创建user
                user = usersService.register(dto.getMobile(), null, null);
            }
            entity.setUserId(user.getId());
        }
        userOrderRecordService.add(entity);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/service/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "修改服务记录", httpMethod = "PUT")
    private Response<Boolean> editService(@RequestBody @Validated UserServiceRecordDto dto){
        UserOrderRecord entity = Transform.dtoToEntity(dto);
        entity.setOrderId(0);
        entity.setProductId(0);
        entity.setProductType(ProductType.SERVICE.key);
        userOrderRecordService.edit(entity);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/service/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除服务记录", httpMethod = "DELETE")
    private Response<Boolean> deleteService(@RequestParam int id){
        userOrderRecordService.delete(id);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/service/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取服务列表", httpMethod = "GET")
    private Response<PageMessage<UserServiceRecordInfoDto>> listService(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String service,
            @RequestParam(required = false) String param,
            @RequestParam(required = false) Integer userId
    ){
        Page<UserOrderRecord> p = userOrderRecordService.listWithServiceAdmin(page, size, ServiceKey.ValueOf(service), param, userId);
        List<UserServiceRecordInfoDto> pr = Transform.convert(p, UserServiceRecordInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserOrderRecord.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserServiceRecordInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/course/appointment/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加课程预约", httpMethod = "POST")
    public Response<UserCourseAppointment> addCourseAppointment(@RequestBody @Validated UserCourseAppointmentDto dto, HttpServletRequest request) {
        UserCourseAppointment entity = Transform.dtoToEntity(dto);
        entity = userCourseAppointmentService.addAppointment(entity);
        managerLogService.log(request);
        return ResponseHelp.success(Transform.convert(entity, CourseTime.class));
    }

    @RequestMapping(value = "/course/appointment/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "编辑课程预约", httpMethod = "PUT")
    public Response<Boolean> editCourseAppointment(@RequestBody @Validated UserCourseAppointmentDto dto, HttpServletRequest request) {
        UserCourseAppointment entity = Transform.dtoToEntity(dto);
        entity = userCourseAppointmentService.edit(entity);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除课程预约", httpMethod = "DELETE")
    public Response<Boolean> deleteCourseAppointment(@RequestParam int id, HttpServletRequest request) {
        userCourseAppointmentService.delete(id);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/detail", method = RequestMethod.GET)
    @ApiOperation(value = "获取课程预约", httpMethod = "GET")
    public Response<CourseTime> detailCourseAppointment(@RequestParam int id,HttpSession session) {
        UserCourseAppointment entity = userCourseAppointmentService.get(id);
        return ResponseHelp.success(Transform.convert(entity, UserCourseAppointment.class));
    }

    @RequestMapping(value = "/course/appointment/list", method = RequestMethod.GET)
    @ApiOperation(value = "课程预约列表", httpMethod = "GET")
    public Response<PageMessage<UserCourseAppointmentInfoDto>> listCourseAppointment(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer[] ids,
            @RequestParam(required = false) Integer recordId,
            HttpSession session) {

        Page<UserCourseAppointment> p;
        if (ids != null && ids.length > 0){
            p = userCourseAppointmentService.select(ids);
        }else{
            p = userCourseAppointmentService.listAdmin(page, size, recordId);
        }
        List<UserCourseAppointmentInfoDto> pr = Transform.convert(p, UserCourseAppointmentInfoDto.class);

        Collection paperIds = Transform.getIds(p, UserCourseAppointment.class, "paperId");
        List<UserPaper> userPaperList = userPaperService.select(paperIds);
        Transform.combine(pr, userPaperList, UserCourseAppointmentInfoDto.class, "paperId", "userPaper", UserPaper.class, "id", UserPaperExtendDto.class);

        // 获取最后一次作业结果
        List<UserReport> reportList = userReportService.listWithLater(paperIds);
        Map reportMap = Transform.getMap(reportList, UserReport.class, "id");
        Transform.combine(pr, reportMap, UserCourseAppointmentInfoDto.class, "paperId", "reportId");

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/invoice/finish", method = RequestMethod.PUT)
    @ApiOperation(value = "开发票", httpMethod = "PUT")
    public Response<Boolean> finishData(
            @RequestParam(required = false) Integer[] ids,
            HttpServletRequest request) {
        userInvoiceService.finish(ids);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/invoice/download", method = RequestMethod.PUT)
    @ApiOperation(value = "下载资料", httpMethod = "PUT")
    public Response<Boolean> downloadData(
            @RequestParam(required = false) Integer[] ids,
            HttpServletRequest request, HttpServletResponse response) throws IOException {
        managerLogService.log(request);
        List<UserInvoice> p = userInvoiceService.select(ids);
        String columnNames[]={"ID","项目名","销售人","负责人","所用技术","备注"};//列名
        String filename = "发票";
        //生成一个Excel文件
        // 创建excel工作簿
        Workbook wb = new HSSFWorkbook();
        // 创建第一个sheet（页），并命名
        Sheet sheet = wb.createSheet();
        // 创建第一行
        Row row = sheet.createRow(0);
        //设置列名
        for(int i=0;i<columnNames.length;i++){
            Cell cell = row.createCell(i);
            cell.setCellValue(columnNames[i]);
        }
        int i = 0;
        for(UserInvoice invoice : p){
            i+=1;
            Row r = sheet.createRow(i);
            Cell cell = r.createCell(0);
            cell.setCellValue(invoice.getId());
        }
        //同理可以设置数据行
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            wb.write(os);
        } catch (IOException e) {
            e.printStackTrace();
        }
        byte[] content = os.toByteArray();
        InputStream is = new ByteArrayInputStream(content);
        // 设置response参数，可以打开下载页面
        response.reset();
        response.setContentType("application/vnd.ms-excel;charset=utf-8");
        response.setHeader("Content-Disposition", "attachment;filename="+ new String((filename + ".xls").getBytes(), "iso-8859-1"));
        ServletOutputStream out = response.getOutputStream();
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(is);
            bos = new BufferedOutputStream(out);
            byte[] buff = new byte[2048];
            int bytesRead;
            // Simple read/write loop.
            while (-1 != (bytesRead = bis.read(buff, 0, buff.length))) {
                bos.write(buff, 0, bytesRead);
            }
        } catch (final IOException e) {
            throw e;
        } finally {
            if (bis != null)
                bis.close();
            if (bos != null)
                bos.close();
        }
        return null;
    }

    @RequestMapping(value = "/invoice/list", method = RequestMethod.GET)
    @ApiOperation(value = "发票列表", httpMethod = "GET")
    public Response<PageMessage<UserInvoiceListDto>> listData(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Boolean isFinish,
            @RequestParam(required = false) Boolean isDownload,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserInvoice> p = userInvoiceService.listAdmin(page, size, userId, isDownload, isFinish);
        List<UserInvoiceListDto> pr = Transform.convert(p, UserInvoiceListDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserInvoice.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserInvoiceListDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        // 绑定订单
        Collection orderIds = Transform.getIds(p, UserInvoice.class, "orderId");
        List<UserOrder> orderList = userOrderService.select(orderIds);
        Transform.combine(pr, orderList, UserInvoiceListDto.class, "orderId", "order", UserOrder.class, "id", UserOrderExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/valid/mobile", method = RequestMethod.GET)
    @ApiOperation(value = "验证手机号", notes="查询手机对应账号", httpMethod = "GET")
    public Response<Boolean> validMobile(
            @RequestParam(required = true) String mobile
    ){
        User user = usersService.getByMobile(mobile);
        if(user == null){
            return ResponseHelp.success(false);
        }else{
            return ResponseHelp.success(true);
        }
    }
}