package com.gimi.common.cinema.utils;

import android.content.Context;
import android.media.MediaPlayer;
import android.text.TextUtils;
import android.util.Log;

import com.gimi.common.cinema.model.AsyncCallback;
import com.gimi.common.cinema.model.FolderItem;
import com.gimi.common.cinema.model.LocalMovieMessage;
import com.gimi.common.cinema.model.MovieMessage;
import com.gimi.common.cinema.model.Rating;
import com.gimi.common.cinema.model.SambaMsg;
import com.xgimi.gimicinema.BuildConfig;
import com.xgimi.gimicinema.R;
import com.xgimi.gimicinema.activity.CinemaConfig;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * movie scan
 * Created by 李攀 on 2015/4/29.
 */
public class LocalMovieScanUtils {
    private String[] picExtensions;
    private String[] mediaExtensions;

    public LocalMovieScanUtils(Context context) {
        picExtensions = context.getResources().getStringArray(R.array.photo_filter);
        mediaExtensions = context.getResources().getStringArray(R.array.video_filter);
    }

    private ArrayList<FolderItem> getTypes(String rootPath) {
        ArrayList<FolderItem> types = new ArrayList<>();
        File file = new File(rootPath);
        String[] fileDirs = file.list();
        if (fileDirs == null || fileDirs.length == 0) {//防止中文目录挂失败
            return types;
        }
        for (String fileDir : fileDirs) {
            File curFile = new File(rootPath + fileDir);
            if (curFile.isDirectory()) {
                FolderItem folderItem = new FolderItem();
                folderItem.setFolderName(fileDir);
                folderItem.setFolderPath(rootPath + fileDir + "/");
//                if (fileDir.contains("AQ")) {
                types.add(folderItem);
//                }
            }
        }
        return types;
    }

    private boolean checkType(String name, String[] extensions) {
        for (String end : extensions) {
            // Name never to null, without exception handling
            if (name.toLowerCase().endsWith(end)) {
                return true;
            }
        }
        return false;
    }

    private String getMedia(String path, String[] extensions) {
        String mediaPath;
        if (path.endsWith(".BD/") || path.endsWith(".ISO/")) {
            mediaPath = getBDPlayPath(path, extensions);
        } else {
            File file = new File(path);
            String[] files = file.list();
            mediaPath = null;
            if (files == null || files.length == 0) {
                return null;
            }
            for (String file1 : files) {
                if (checkType(path + file1, extensions)) {
                    mediaPath = path + file1;
                    break;
                }
            }
        }
        return mediaPath;
    }

    private String getMediaPicture(String path, String[] extensions) {
        String posterPath;

        File file = new File(path);
        String[] files = file.list();
        if (files == null || files.length == 0) {
            return null;
        }
        posterPath = null;
        for (String file1 : files) {
            if (checkType(path + file1, extensions)) {
                posterPath = path + file1;
                break;
            }
        }
        return posterPath;
    }

    private String getBDPlayPath(String path, String[] extensions) {
        String mediaPath = null;

        ArrayList<String> strings1 = new ArrayList<>();
        ArrayList<String> strings = find(path, extensions, strings1);
        if (strings.size() >= 1) {
            for (String string : strings) {
                mediaPath = getBiggerVideoPath(mediaPath, string);
            }
        }
        return mediaPath;
    }

    private ArrayList<String> find(String path, String[] reg, ArrayList<String> result) {
        File file = new File(path);
        File[] arr = file.listFiles();
        for (File anArr : arr) {
            //判断是否是文件夹，如果是的话，再调用一下find方法
            if (anArr.isDirectory()) {
                find(anArr.getAbsolutePath(), reg, result);
            } else if (checkType(anArr.getAbsolutePath(), reg)) {
                result.add(anArr.getAbsolutePath());
            }
        }
        return result;
    }

    private String getBiggerVideoPath(String oldPath, String newPath) {
        if (oldPath == null) {
            return newPath;
        }
        File oFile = new File(oldPath);
        File nFile = new File(newPath);

        if (oFile.length() > nFile.length()) {
            return oldPath;
        }

        return newPath;
    }

    private void setDoubanMsg(String mmPath, LocalMovieMessage localMovieMessage) {
        MovieMessage mm = MovieMessageUtils.getLocalMovieMessage(mmPath);
        if (mm != null) {
            Rating rating = mm.getRating();
            double average = 0;//rating
            if (rating != null) {
                average = rating.getAverage();
            }
            String[] genres = mm.getGenres();
            //clazz
            if (!TextUtils.isEmpty(mm.getId())) {
                localMovieMessage.setDoubanId(mm.getId());
            }
            //types
            StringBuilder types = new StringBuilder();
            localMovieMessage.setDoubanRating(average);
            if (genres.length > 0) {
                types.append(genres[0]);
            }
            for (int i = 1; i < genres.length; i++) {
                types.append("/").append(genres[i]);
            }
            localMovieMessage.setScreenTime(mm.getYear());
            localMovieMessage.setClassDescribe(types.toString());
        }
    }

    /**
     * scan movies like
     * /mnt/samba/172.21.16.252/root1
     * /mnt/samba/172.21.16.252/root2
     * /mnt/samba/172.21.16.252/folder
     *
     * @param rootPath /mnt/samba/172.21.16.252/
     * @param callback callback
     * @return ArrayList<LocalMovieMessage>
     */
    ArrayList<LocalMovieMessage> getAllLocalMovie(String rootPath, String folder, AsyncCallback<Integer> callback) {
        LogUtils.i("scan-time", "start:" + System.currentTimeMillis());
        ArrayList<String> all = new ArrayList<>();
        File file = new File(rootPath);
        if (file.listFiles() != null) {
            for (File file1 : file.listFiles()) {
                if (file1.isDirectory()) {
                    String absolutePath = file1.getAbsolutePath() + "/";
                    if (new File(absolutePath + "TJ").exists()) {
                        all.add(absolutePath);
                    }
                }
            }
        }

        if (BuildConfig.MACHINE_TYPE.equals("himedia")) {
            all.add(CinemaConfig.BASIC_ROOT + "/");
        }
        if (!TextUtils.isEmpty(folder)) {
            String s = rootPath + folder + File.separator;
            if (new File(s).exists()) {
                if (new File(s + "TJ/").exists()) {
                    if (!all.contains(s)) {
                        all.add(s);
                    }
                }
                File file1 = new File(s);
                String[] list = file1.list();
                if (list != null && list.length != 0) {
                    for (String s1 : list) {
                        if (new File(s + s1 + File.separator + "TJ/").exists()) {
                            all.add(s + s1 + File.separator);
                        }
                    }
                }
            }
        }
        if (!all.contains(rootPath + folder + File.separator)) {
            all.add(rootPath + folder + File.separator);
        }
        ArrayList<LocalMovieMessage> moviesItems = new ArrayList<>();
        for (String s : all) {
            ArrayList<FolderItem> types = getTypes(s);
            for (FolderItem type : types) {
                moviesItems.addAll(getAllType(type.getFolderPath(), callback));
            }
        }
        LogUtils.i("scan-time", "  end:" + System.currentTimeMillis());
        return moviesItems;
    }

    public ArrayList<LocalMovieMessage> getAllLocalMovie(SambaMsg msg, AsyncCallback<Integer> callback) {
        if (BuildConfig.MACHINE_TYPE.equals("himedia")) {
            return getAllLocalMovie(CinemaConfig.BASIC_ROOT, msg.getFolder(), callback);
        }
        return getAllLocalMovie(msg.getRootPath(), msg.getFolder(), callback);
    }


    public ArrayList<LocalMovieMessage> getAllFolderMovies(String rootPath, AsyncCallback<Integer> callback) {
        return getAllType(rootPath, callback);
    }

    /**
     * 扫描电影文件夹添加必要信息
     *
     * @param rootPath movie folder path
     * @param callback callback
     * @return ArrayList<LocalMovieMessage>
     */
    private ArrayList<LocalMovieMessage> getAllType(String rootPath, AsyncCallback<Integer> callback) {
        long inTime = System.currentTimeMillis();
        ArrayList<LocalMovieMessage> movies = new ArrayList<>();
        if (rootPath.contains("lost+found")) {
            LogUtils.i("scan-time-total", "scan " + rootPath + " size:0" + " total time:" + (System.currentTimeMillis() - inTime));
            return movies;
        }
        if (callback != null) {
            String[] split = rootPath.split("/");
            callback.onMessage(split[split.length - 1]);
        }
        File file = new File(rootPath);
        String[] fileDirs = file.list();
        //遍历
        if (fileDirs == null || fileDirs.length == 0) {
            LogUtils.i("scan-time-total", "scan " + rootPath + " size:0" + " total time:" + (System.currentTimeMillis() - inTime));
            return movies;
        }
        int length = fileDirs.length;
        int coreCount = 4;
        int poolCount = 9;
//        coreCount = fileDirs.length < 100 ? 1 : coreCount;
        ThreadPoolExecutor myExecutor = new ThreadPoolExecutor(coreCount, poolCount,
                200, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
        List<Future<ArrayList<LocalMovieMessage>>> results = new ArrayList<>();
        for (int i = 0; i < coreCount; i++) {
            ScanTask task = new ScanTask(rootPath, Arrays.copyOfRange(
                    fileDirs, length * i / coreCount, (length * (i + 1)) / coreCount));
            Future<ArrayList<LocalMovieMessage>> result = myExecutor.submit(task);
            results.add(result);
        }
        for (Future<ArrayList<LocalMovieMessage>> f : results) {
            try {
                movies.addAll(f.get());
            } catch (Exception ex) {
                ex.printStackTrace();
                f.cancel(true);
            }
        }
        myExecutor.shutdown();
        LogUtils.i("scan-time-total", "scan " + rootPath + " size:" + movies.size() + " total time:" + (System.currentTimeMillis() - inTime));
        return movies;
    }

    private class ScanTask implements Callable<ArrayList<LocalMovieMessage>> {
        private String rootPath;
        private String[] dirs;

        private ScanTask(String rootPath, String[] dirs) {
            this.rootPath = rootPath;
            this.dirs = dirs;
        }

        @Override
        public ArrayList<LocalMovieMessage> call() throws Exception {
            ArrayList<LocalMovieMessage> movies = new ArrayList<>();
            for (String fileDir : dirs) {
                File curFiles = new File(rootPath + fileDir);
                if (curFiles.isDirectory()) {
                    String curPath = curFiles.getAbsoluteFile().toString();
                    LocalMovieMessage moviesItem = new LocalMovieMessage();
                    String name = NameFilterUtils.getName(fileDir).trim();
                    moviesItem.setMovieName(name);
                    String allFirstSpell = PinyinUtil.getAllFirstSpell(name);
                    String newStr = allFirstSpell.replaceAll("[^\\w,]", "");
                    moviesItem.setNamePinyin(newStr);
                    String media = getMedia(curPath + "/", mediaExtensions);
                    String poster;
                    poster = MovieMessageUtils.getLocalMoviePoster(curPath);
                    if (TextUtils.isEmpty(poster)) {
                        poster = getMediaPicture(curPath + "/", picExtensions);
                    }
                    if (!TextUtils.isEmpty(poster)) {
                        moviesItem.setPosterPath(poster);
                    }
                    if (!TextUtils.isEmpty(media)) {
                        File mFile = new File(media);
//                    long length = mFile.length();
                        String md5 = MD5Utils.stringMD5(FileHashUtils.getFileHash(media));
                        moviesItem.setMd5(md5);
                        //read douban id and douban msg,至于name id 信息另外做，没有必要每次更新时都去添加
                        try {
                            setDoubanMsg(curPath, moviesItem);
                        } catch (Exception e) {
                            Log.e("otherError", media);
                            e.printStackTrace();
                        }
                        moviesItem.setType(fileDir);
                        moviesItem.setPlayPath(media);
                        String movieLength = readMovieLengthFile(curPath, md5);
                        if (movieLength != null) {
                            moviesItem.setMovieLength(movieLength);
                        }
                        String movieDlTime = String.valueOf(mFile.lastModified());
                        moviesItem.setDlTime(movieDlTime);
                        moviesItem.setCount(MovieMessageUtils.getPlayCount(curPath));
                        movies.add(moviesItem);
                    }
                }
            }
            return movies;
        }

        /**
         * 读取时长文件值
         *
         * @param playPath 路径
         * @param md5      电影MD5
         * @return 时长
         */
        private String readMovieLengthFile(String playPath, String md5) {

            File timeFile = new File(playPath, md5);

            String timeLength = null;
            if (SambaFileCharge.fileExist(timeFile.getPath())) {
                BufferedReader reader = null;
                try {
                    reader = new BufferedReader(new FileReader(timeFile));
                    timeLength = reader.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (reader != null) {
                        try {
                            reader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                }
            }
            return timeLength;
        }
    }

    /**
     * The default thread factory.
     */
    private static class MyThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        MyThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);

            t.setDaemon(true);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    private synchronized long getDuration(String path) {
        long in = System.currentTimeMillis();
        MediaPlayer mMediaPlayer = new MediaPlayer();
        try {
            mMediaPlayer.setDataSource(path);
        } catch (IOException e) {
            e.printStackTrace();
        }
        int duration = mMediaPlayer.getDuration();
        Log.d("duration", (System.currentTimeMillis() - in) + ":" + duration);
        return duration;
    }

    private long getMovieLength(String mUri) {
        long l = System.currentTimeMillis();

        long duration = 5400000;
        android.media.MediaMetadataRetriever mmr = new android.media.MediaMetadataRetriever();

        try {
            if (mUri != null) {
                HashMap<String, String> headers = null;
                if (headers == null) {
                    headers = new HashMap<String, String>();
                    headers.put("User-Agent", "Mozilla/5.0 (Linux; U; Android 4.4.2; zh-CN; MW-KW-001 Build/JRO03C) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 UCBrowser/1.0.0.001 U4/0.8.0 Mobile Safari/533.1");
                }
                mmr.setDataSource(mUri, headers);
            }

            String durationStr = mmr.extractMetadata(android.media.MediaMetadataRetriever.METADATA_KEY_DURATION);
            duration = Long.parseLong(durationStr);
        } catch (Exception ex) {
        } finally {
            mmr.release();
        }
        Log.d("getAllType", "" + (System.currentTimeMillis() - l));
        return duration;
    }
}