package com.peanut.modules.book.controller;

import java.io.File;
import java.io.FileInputStream;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.alibaba.druid.util.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.peanut.common.utils.BaiduVoicesUtils;
import com.peanut.modules.book.entity.*;
import com.peanut.modules.book.service.*;
import com.peanut.modules.oss.service.OssService;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.peanut.common.utils.PageUtils;
import com.peanut.common.utils.R;
import org.springframework.web.multipart.MultipartFile;


/**
 * @author yl
 * @email yl328572838@163.com
 * @date 2022-08-16 14:32:06
 */
@Slf4j
@RestController
@RequestMapping("book/bookchaptercontent")
public class BookChapterContentController {
    @Autowired
    private BookChapterContentService bookChapterContentService;
    @Autowired
    private BookService bookService;
    @Autowired
    private OssService ossService;
    @Autowired
    private BookChapterService bookChapterService;
    @Autowired
    private MyUserService myUserService;
    @Autowired
    private UserEbookBuyService userEbookBuyService;
    @Autowired
    private ShopProductBookService shopProductBookService;

    /**
     * 列表
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params) {
        PageUtils page = bookChapterContentService.queryPage(params);

        return R.ok().put("page", page);
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Integer id) {
        BookChapterContentEntity bookChapterContent = bookChapterContentService.getById(id);

        return R.ok().put("bookChapterContent", bookChapterContent);
    }

    /**
     * 保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody BookChapterContentEntity bookChapterContent) {
        bookChapterContentService.save(bookChapterContent);

        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody BookChapterContentEntity bookChapterContent) {
        bookChapterContentService.updateById(bookChapterContent);

        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids) {
        bookChapterContentService.removeByIds(Arrays.asList(ids));

        return R.ok();
    }


    /**
     * 章节拆分转换单句
     */
    @RequestMapping("/getBookVoices")
    public R getBookVoices(@RequestParam("id") Integer id) {

        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        singleThreadExecutor.execute(() -> bookChapterContentService.getWordChapterParagraph(id));

        BookEntity bookEntity = bookService.getBaseMapper().selectById(id);
        bookEntity.setContentStatus("2");
        bookService.updateById(bookEntity);

        return R.ok();
    }

    /**
     * 章节单句 转成音频
     */
    @RequestMapping("/signVoices")
    public R signVoices(@RequestParam("content") String content) throws Exception {
        //调用百度语音合成 API
        String voices = BaiduVoicesUtils.run(content);
        File file = new File(voices);
        if (!file.exists()) {
            return R.error("语音文件未生成");
        }
        FileInputStream fileInputStream = new FileInputStream(file);
        MultipartFile multipartFile = new MockMultipartFile("file", file.getName(), "text/plain", IOUtils.toByteArray(fileInputStream));
        String path = ossService.uploadFileAvatar(multipartFile);
        fileInputStream.close();
        file.delete();

        if (StringUtils.isEmpty(path)) {
            return R.error("语音上传失败");
        }

        return R.ok().put("voices", path);
    }

    /**
     * 全部章节单句 转成音频
     */
    @RequestMapping("/allVoices")
    public R allVoices(@RequestParam("id") Integer id) throws Exception {

        BookEntity bookEntity = bookService.getBaseMapper().selectById(id);
        //创建单线程
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        singleThreadExecutor.execute(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                BookEntity bookEntity = bookService.getBaseMapper().selectById(id);
                List<BookChapterContentEntity> book_id = bookChapterContentService.getBaseMapper().selectList(new QueryWrapper<BookChapterContentEntity>()
                        .eq("book_id", id));

                for (BookChapterContentEntity bookContent : book_id) {
                    String content = bookContent.getContent();
                    //生成相应的语音文件
                    String voices = BaiduVoicesUtils.run(content);

                    File file = new File(voices);
                    if (!file.exists()) {
                        bookEntity.setVoicesStatus("3");
                    }
                    FileInputStream fileInputStream = new FileInputStream(file);

                    //把 voices 音频文件读入到内存中并将其转换成MultipartFile格式文件 multipartFile 用于OSS上传
                    // application/x-www-form-urlencoded  form表单数据被编码为key/value格式发送到服务器
                    // text/plain  纯文本格式
//                    MultipartFile multipartFile =new MockMultipartFile("file", file.getName(), "text/plain", IOUtils.toByteArray(fileInputStream));
                    MultipartFile multipartFile = new MockMultipartFile("file", file.getName(), "text/plain", IOUtils.toByteArray(fileInputStream));
                    //上传 multipartFile 文件到阿里云OSS上
                    String path = ossService.uploadFileAvatar(multipartFile);

                    bookContent.setVoices(path);

                    fileInputStream.close();

                    file.delete();

                    bookChapterContentService.updateById(bookContent);
                    if (StringUtils.isEmpty(path)) {
                        bookEntity.setVoicesStatus("3");
                    }
                }
                bookEntity.setVoicesStatus("2");
                bookService.updateById(bookEntity);
            }
        });
        bookEntity.setVoicesStatus("1");
        bookService.updateById(bookEntity);
        return R.ok();
    }

    //章节2.0转音频
    @RequestMapping("/AllVOices")
    public R allVoicess2(@RequestParam("id") Integer id) throws Exception {

        BookEntity bookEntity = bookService.getBaseMapper().selectById(id);
        //创建单线程
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        singleThreadExecutor.execute(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                BookEntity bookEntity = bookService.getBaseMapper().selectById(id);

                List<BookChapterEntity> book_id = bookChapterService.getBaseMapper().selectList(new QueryWrapper<BookChapterEntity>().eq("book_id", id));


                for (BookChapterEntity bookChapter : book_id) {
                    String content = bookChapter.getContent();
                    //生成相应的语音文件
                    String voices = BaiduVoicesUtils.run(content);

                    File file = new File(voices);
                    if (!file.exists()) {
                        bookEntity.setVoicesStatus("3");
                    }
                    FileInputStream fileInputStream = new FileInputStream(file);
                    MultipartFile multipartFile = new MockMultipartFile("file", file.getName(), "text/plain", IOUtils.toByteArray(fileInputStream));
                    //上传 multipartFile 文件到阿里云OSS上
                    String path = ossService.uploadFileAvatar(multipartFile);

                    bookChapter.setVoices(path);

                    fileInputStream.close();

                    file.delete();

                    bookChapterService.updateById(bookChapter);
                    if (StringUtils.isEmpty(path)) {
                        bookEntity.setVoicesStatus("3");
                    }
                }
                bookEntity.setVoicesStatus("2");
                bookService.updateById(bookEntity);
            }
        });
        bookEntity.setVoicesStatus("1");
        bookService.updateById(bookEntity);
        return R.ok();
    }

    /**
     * 鉴权获取章节
     *
     * @param bookid
     * @param userId
     * @return
     */
    @RequestMapping("/getBooksCatal")
    public R getBooksCatal(@RequestParam("id") Integer id,
                           @RequestParam("bookid") Integer bookid,
                           @RequestParam("userId") Integer userId) {
        // TODO 验证 当前请求的书 是否存在免费章节数
        BookEntity bookEntity = bookService.getBaseMapper().selectById(bookid);
        Integer freeChapterCount = bookEntity.getFreeChapterCount();

        //TODO  0-免费  1-会免（改为电子书听书）  2-付费   //  阅读章节数  大于  免费章节数
        Integer isVip = bookEntity.getIsVip();
        if ((bookid > freeChapterCount) || freeChapterCount == 0) {
            //  书籍为  会免

            if (isVip == 1) {
                //查询用户身份
                MyUserEntity user = myUserService.getById(userId);
                String vip = user.getVip();
                if (!"1".equals(vip)) {

                    return R.error("当前为VIP");
                }

            }

        }
        if (isVip == 2) {
            // 鉴权   查询权限表中 用户是否开通
            boolean b = myUserService.bookAuthenticate(bookid, userId);

            if (!b) {
                return R.error(500, "请购买书籍！");
            }
        }
        if (isVip == 3) {
            boolean b = myUserService.bookAuthenticate(bookid, userId);
            if (!b) {

                List<BookChapterEntity> book = bookChapterService.getBaseMapper().selectList(new QueryWrapper<BookChapterEntity>()
                        .eq("book_id", bookid));
                ArrayList<Object> chapterList = new ArrayList<>();
                int chapterIndex = 0;
                for (BookChapterEntity chapter : book) {
                    if (chapterIndex >= freeChapterCount) {
                        break; // 取出前freeChapterCount条记录后，退出循环
                    }
                    //获取条数记录，取出对应name,url
                    Map<String, Object> map = new HashMap<>();
                    map.put("name", chapter.getChapter());
                    map.put("url", chapter.getVoices());

                    chapterList.add(map);

                    chapterIndex++;

                }
                return R.ok("当前为试听章节：" + chapterList).put("bookCatalogue", chapterList).put("image", bookEntity.getImages()).put("chapterIndex", chapterIndex);
            }
        }


        List<BookChapterEntity> book = bookChapterService.getBaseMapper().selectList(new QueryWrapper<BookChapterEntity>()
                .eq("book_id", bookid));
        ArrayList<Object> chapterList = new ArrayList<>();
        for (BookChapterEntity chapter : book) {
            Map<String, Object> map = new HashMap<>();
            map.put("name", chapter.getChapter());
            map.put("url", chapter.getVoices());
            chapterList.add(map);
        }
        return R.ok().put("bookCatalogue", chapterList).put("image", bookEntity.getImages());

    }

    /**
     * 获取章节音频地址
     *
     * @return
     */
    @RequestMapping("/getBooksCatalogue")
    public R getBooksCatalogue(@RequestParam Integer chapterId,
                               @RequestParam Integer bookId,
                               @RequestParam Integer userId) {
        //鉴权阶段
        BookEntity book_info = bookService.getById(bookId);
        BookChapterEntity chapter_info = bookChapterService.getById(chapterId);

        UserEbookBuyEntity userEbookBuyEntity = userEbookBuyService.getBaseMapper().selectOne(new LambdaQueryWrapper<UserEbookBuyEntity>().
                eq(UserEbookBuyEntity::getUserId, userId).eq(UserEbookBuyEntity::getBookId, bookId));
        if (book_info.getBookType()==0&&chapter_info.getNumber() > book_info.getFreeChapterCount() && userEbookBuyEntity == null) {
            Integer productByBookId = shopProductBookService.getProductByBookId(bookId);
            return R.ok().put("jq", false).put("product", productByBookId);
        }


        return R.ok().put("chapter", chapter_info);
    }


    /**
     * app 获取电子书章节内容 2.0  (在用鉴权)
     */
    @RequestMapping("/appBooksChapterContent1")
    public R getBooksCatalogue1(@RequestParam("chapterid") Integer id,
                                @RequestParam("bookid") Integer bookid,
                                @RequestParam("userId") Integer userId) {
        // TODO 验证 当前请求的书 是否存在免费章节数
        BookEntity bookEntity = bookService.getBaseMapper().selectById(bookid);
        Integer freeChapterCount = bookEntity.getFreeChapterCount();

        BookChapterEntity bookChapterEntity = bookChapterService.getBaseMapper().selectById(id);

        Integer number = bookChapterEntity.getNumber();

        //TODO  0-免费  1-会免（改为电子书听书）  2-付费   //  阅读章节数  大于  免费章节数
        Integer isVip = bookEntity.getIsVip();
        Boolean canListen = bookEntity.getCanListen();

        //todo  暂未开通听书功能
//    if (canListen==false) {
//        return R.error1("暂未开通听书功能");
//    }

        if ((number > freeChapterCount) || freeChapterCount == 0) {
            //  书籍为  会免

            if (isVip == 1) {
                //查询用户身份
                MyUserEntity user = myUserService.getById(userId);
                String vip = user.getVip();
                if (!"1".equals(vip)) {

                    return R.error("当前为VIP");
                }

            }

            if (canListen == true) {
                boolean b = myUserService.bookAuthenticate(bookid, userId);
                if (!b) {

                    return R.error("未购买书籍！");
                }
            }


        }


        if (isVip == 2) {
            // 鉴权   查询权限表中 用户是否开通
            boolean b = myUserService.bookAuthenticate(bookid, userId);

            if (!b) {
                return R.error(500, "请购买书籍！").put("code", 500);

            }
        }


        ArrayList<Object> chapterList = new ArrayList<>();


        Map<String, Object> map = new HashMap<>();
        map.put("name", bookChapterEntity.getChapter());
        map.put("url", bookChapterEntity.getVoices());
        map.put("bookid", bookChapterEntity.getBookId());
        map.put("chapterid", bookChapterEntity.getId());
        //todo  sort先注释调
//        map.put("sort",bookChapterEntity.getSort());
        chapterList.add(map);

        return R.ok().put("bookCatalogue", chapterList).put("image", bookEntity.getImages());

    }


    /**
     * app 获取电子书章节内容
     */
    @RequestMapping("/appGetBookChapterContent")
    public R getBookCatalogue(@RequestParam("chapterid") Integer chapterid,
                              @RequestParam("bookid") Integer bookid,
                              @RequestParam("userId") Integer userId) {

        // TODO 验证 当前请求的书 是否存在免费章节数
        BookEntity bookEntity = bookService.getBaseMapper().selectById(bookid);
        Integer freeChapterCount = bookEntity.getFreeChapterCount();
        Integer isVip = bookEntity.getIsVip();   //  0-免费  1-会免  2-付费
        BookChapterEntity bookChapterEntity = bookChapterService.getBaseMapper().selectById(chapterid);
        Integer number = bookChapterEntity.getNumber();
        //  阅读章节数  大于  免费章节数
        if ((number > freeChapterCount) || freeChapterCount == 0) {
            if (isVip == 1) {
                MyUserEntity user = myUserService.getById(userId);
                String vip = user.getVip();
                if (!"1".equals(vip)) {
                    return R.error(500, "当前书籍为会员书籍，请开通会员或购买！");
                }

            }
            if (isVip == 2) {
                boolean b = myUserService.bookAuthenticate(bookid, userId);
                if (!b) {
                    return R.error(500, "请购买此书籍！");
                }
            }
        }


        ArrayList<Object> list = new ArrayList<>();
        List<BookChapterContentEntity> bookChapterContentEntities = bookChapterContentService.getBaseMapper().selectList(new QueryWrapper<BookChapterContentEntity>()
                .eq("book_id", bookid)
                .eq("book_chatper_id", chapterid));
        for (BookChapterContentEntity bookChapterContentEntity : bookChapterContentEntities) {

            String content = bookChapterContentEntity.getContent();

            String substring = "";
            if (bookChapterContentEntity.getOtherContent() != null) {
                substring = bookChapterContentEntity.getOtherContent().replace("<p>", "").replace("</p>", "");
            }
            StringBuffer stringBuffer = new StringBuffer(substring);
            if (stringBuffer.indexOf("title") != -1) {
                stringBuffer.insert(stringBuffer.indexOf("title"), "width=\"100%\"");
            }
            if (bookChapterContentEntity.getNumber() == 1) {
                Integer bookChatperId = bookChapterContentEntity.getBookChatperId();
                BookChapterEntity chapterEntity = bookChapterService.getById(bookChatperId);
                String chapter = chapterEntity.getChapter();
                content = bookChapterContentEntity.getContent().replace(chapter, "");
            }
            bookChapterContentEntity.setPicAndWord(content.replaceAll(" ", "") + stringBuffer);
            list.add(bookChapterContentEntity);
        }

        return R.ok().put("bookCatalogue", list);
    }

    //生成电子书 目录
    @RequestMapping("/getWordChapterParagraph")
    public R getWordChapterParagraph(@RequestParam Map<String, Object> params) {
        bookChapterContentService.getWordChapterParagraph(14);
        return R.ok();
    }

}