package com.manatee.demo.controller;

import com.alibaba.fastjson.JSONObject;
import com.manatee.common.util.FileUtil;
import com.manatee.lowcode.constant.FileConstant;
import com.manatee.lowcode.domain.WebResult;
import com.manatee.lowcode.util.ConfUtil;
import com.manatee.lowcode.util.ManateeExportUtil;
import com.manatee.lowcode.util.WebUtil;
import com.manatee.lowcode.web.manager.CustomizeModuleManager;
import com.manatee.process.constant.ProcessConstant;
import com.manatee.process.domain.ProcessContent;
import com.manatee.process.domain.ProcessFileInfo;
import com.manatee.process.execute.DebugUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.*;
import java.util.List;
import java.util.stream.Collectors;

import static com.manatee.process.constant.ProcessConstant.Key.FILE;
import static com.manatee.process.constant.ProcessConstant.Key.FILES;

/**
 * Created by ziyue on 2018/6/2.
 */
@Slf4j
@Controller
@RequestMapping("/biz")
public class ModularityController {

    @Autowired
    private CustomizeModuleManager customizeModuleManager;

    @Autowired
    private ManateeExportUtil manateeExportUtil;

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularity/project{projectId}/{code}", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> doModularityGet(HttpServletRequest request, HttpServletResponse response,
                                      @PathVariable Long projectId,
                                      @PathVariable String code) {
        ProcessContent content = new ProcessContent();
        initParam(content,request);
        content.setCode(code);
        content.setProjectId(projectId);
        JSONObject customize = customizeModuleManager.customize(request, content);
        JSONObject exportResult = getExportData(content, customize);
        ResponseEntity<Object> responseEntity = buildResponse(request, content, customize, exportResult);
        return responseEntity;
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularity/project{projectId}/{code}", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> doModularityPost(HttpServletRequest request, HttpServletResponse response,
                                       @RequestBody(required = false) JSONObject data,
                                       @PathVariable Long projectId,
                                       @PathVariable String code) {
        ProcessContent content = new ProcessContent();
        initParam(content,request);
        content.putRequest(data);
        content.setCode(code);
        content.setProjectId(projectId);
        JSONObject customize = customizeModuleManager.customize(request, content);
        JSONObject exportResult = getExportData(content, customize);
        ResponseEntity<Object> responseEntity = buildResponse(request, content, customize, exportResult);
        return responseEntity;
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularityUpload/project{projectId}/{code}", method = RequestMethod.POST)
    @ResponseBody
    public JSONObject doModularityUpload(@RequestParam(FILE) MultipartFile file, HttpServletRequest request,
                                         @PathVariable Long projectId,
                                         @PathVariable String code) {
        ProcessContent content = new ProcessContent();
        try {
            initParam(content,request);
            content.putTempContent(ProcessConstant.Key.CODE, code);
            content.putTempContent(ProcessConstant.Key.PROJECT_ID, projectId);
            content.setFile(file.getInputStream());
            content.setFileName(file.getOriginalFilename());
            JSONObject result = customizeModuleManager.customize(request, content);
            return result;
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
        WebResult result = WebUtil.wirteResult(content);
        return result.toJson();
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularityExport/project{projectId}/{code}", method = RequestMethod.GET)
    @ResponseBody
    public void doModularityExport(HttpServletRequest request, HttpServletResponse response,
                                   @PathVariable Long projectId,
                                   @PathVariable String code) {
        ProcessContent content = new ProcessContent();
        try {
            initParam(content,request);
            content.putTempContent(ProcessConstant.Key.CODE, code);
            content.putTempContent(ProcessConstant.Key.PROJECT_ID, projectId);
            JSONObject customize = customizeModuleManager.customize(request, content);
            JSONObject result = getExportData(content,customize);
            manateeExportUtil.exprotToResponse(result,response);
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularityExport/project{projectId}/{code}", method = RequestMethod.POST)
    @ResponseBody
    public void doModularityExport(HttpServletRequest request, HttpServletResponse response,
                                   @RequestBody(required = false) JSONObject data,
                                   @PathVariable Long projectId,
                                   @PathVariable String code) {
        ProcessContent content = new ProcessContent();
        try {
            initParam(content,request);
            content.putRequest(data);
            content.putTempContent(ProcessConstant.Key.CODE, code);
            content.putTempContent(ProcessConstant.Key.PROJECT_ID, projectId);
            JSONObject customize = customizeModuleManager.customize(request, content);
            JSONObject result = getExportData(content,customize);
            manateeExportUtil.exprotToResponse(result,response);
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
    }

    protected void initParam(ProcessContent content, HttpServletRequest request){
        content.putTempContent("userId", 2);
    }

    protected JSONObject getExportData(ProcessContent content, JSONObject customize){
        String backStructure = content.getProjectConf().getString("backStructure");
        if (StringUtils.isNotEmpty(backStructure)) {
            JSONObject backStructureJson = JSONObject.parseObject(backStructure);
            String dataKey = backStructureJson.getJSONObject("customKeys").getString("data");
            JSONObject result = customize.getJSONObject(dataKey);
            return result;
        }
        return customize.getJSONObject("data");
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/customizeModule.do", method = RequestMethod.GET)
    @ResponseBody
    public JSONObject doCustomizeModule(HttpServletRequest request, HttpServletResponse response) {
        ProcessContent content = new ProcessContent();
        return customizeModuleManager.customize(request, content);
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/customizeModule.do", method = RequestMethod.POST)
    @ResponseBody
    public JSONObject doCustomizeModulePost(HttpServletRequest request, HttpServletResponse response,
                                            @RequestBody(required = false) JSONObject data) {
        ProcessContent content = new ProcessContent();
        content.putRequest(data);
        return customizeModuleManager.customize(request, content);
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/customizeModuleFile.do", method = RequestMethod.POST)
    @ResponseBody
    public JSONObject doCustomizeModuleFile(@RequestParam(FILE) MultipartFile file,HttpServletRequest request) {
        ProcessContent content = new ProcessContent();
        try {
            content.setFile(file.getInputStream());
            content.setFileName(file.getOriginalFilename());
            return customizeModuleManager.customize(request, content);
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
        WebResult result = WebUtil.wirteResult(content);
        return result.toJson();
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/customizeModuleExport.do", method = RequestMethod.GET)
    @ResponseBody
    public void customizeModuleExport(HttpServletRequest request,HttpServletResponse response) {
        ProcessContent content = new ProcessContent();
        try {
            JSONObject customize = customizeModuleManager.customize(request, content);
            JSONObject result = getExportData(content,customize);
            manateeExportUtil.exprotToResponse(result,response);
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/customizeModuleExport.do", method = RequestMethod.POST)
    @ResponseBody
    public void customizeModuleExportPost(HttpServletRequest request,HttpServletResponse response,
                                          @RequestBody(required = false) JSONObject data) {
        ProcessContent content = new ProcessContent();
        try {
            content.putRequest(data);
            JSONObject customize = customizeModuleManager.customize(request, content);
            JSONObject result = getExportData(content,customize);
            manateeExportUtil.exprotToResponse(result,response);
        } catch (Throwable e) {
            e.printStackTrace();
            content.addException(e);
        }
    }

    @CrossOrigin(origins = "*")
    @RequestMapping(path = "/modularity/helloManatee", method = RequestMethod.GET)
    @ResponseBody
    public String helloManatee(){
        return "Hello Manatee!";
    }

    private ResponseEntity<Object> buildResponse(HttpServletRequest request, ProcessContent content, JSONObject customizeResult, JSONObject exportResult) {
        if (DebugUtil.isDebug(content)) {
            return ResponseEntity.ok(customizeResult);
        } else {
            // 版本校验，接口版本2.6及以上走新逻辑
            boolean isModularityController = ConfUtil.isModularityController(content);
            if (!isModularityController) {
                return ResponseEntity.ok(customizeResult);
            }

            FileResponse fileResponse = new FileResponse();
            HttpHeaders fileHeader = buildFileHeader(exportResult, fileResponse);
            if (fileHeader == null) {
                return ResponseEntity.ok(customizeResult);
            } else {
                return ResponseEntity.ok().headers(fileHeader).body(fileResponse.getBytes());
            }
        }
    }

    private HttpHeaders buildFileHeader(JSONObject data, FileResponse fileResponse) {
        if (data == null) {
            return null;
        }
        String lowcodeTempExcelUrl = data.getString(FileConstant.LOWCODE_TEMP_EXCEL_URL);
        String lowcodeTempFileUrl = data.getString(FileConstant.LOWCODE_TEMP_FILE_URL);
        String lowcodeFileUrl = data.getString(FileConstant.LOWCODE_FILE_URL);
        String url;
        boolean needDelete = true;
        if (lowcodeTempExcelUrl != null && !lowcodeTempExcelUrl.isEmpty()) {
            url = lowcodeTempExcelUrl;
        } else if (lowcodeTempFileUrl != null && !lowcodeTempFileUrl.isEmpty()) {
            url = lowcodeTempFileUrl;
        } else if (lowcodeFileUrl != null && !lowcodeFileUrl.isEmpty()) {
            url = lowcodeFileUrl;
            needDelete = false;
        } else {
            return null;
        }
        File fileOutput = new File(url);

        try {
            if (fileOutput.exists()) {
                // 如果文件存在，读取文件流
                InputStream inputStream = new FileInputStream(fileOutput);
                byte[] bytes = IOUtils.toByteArray(inputStream);
                fileResponse.setBytes(bytes);
                // 设置响应头信息
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.MULTIPART_FORM_DATA);
                String formFileName = java.net.URLEncoder.encode(fileOutput.getName(), "UTF-8");
                headers.setContentDisposition(ContentDisposition.builder("attachment").filename(formFileName).build());
                headers.setContentLength(bytes.length);
                if (needDelete) {
                    FileUtil.deleteFile(url);
                }
                return headers;
            } else {
                return null;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    private void setFile(ProcessContent content, MultipartFile file, List<MultipartFile> files) {
        try {
            if (file != null) {
                content.setFile(file.getInputStream());
                content.setFileName(file.getOriginalFilename());
            }
            if (files != null) {
                List<ProcessFileInfo> processFileInfos = files.stream().map(item -> {
                    ProcessFileInfo processFileInfo = new ProcessFileInfo();
                    try {
                        processFileInfo.setInputStream(item.getInputStream());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    processFileInfo.setFileName(item.getOriginalFilename());
                    return processFileInfo;
                }).collect(Collectors.toList());
                content.setFiles(processFileInfos);
            }
        } catch (Exception e) {
            log.error("文件上传异常", e);
            content.addException(e);
        }
    }

    @Data
    class FileResponse {
        private byte[] bytes;
    }

}