package com.gimi.common.cinema.utils;

import android.text.TextUtils;
import android.util.Log;
import android.view.TextureView;

import com.gimi.common.cinema.model.CinemaConfig;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.google.gson.reflect.TypeToken;

import java.io.*;
import java.util.ArrayList;

import static com.nostra13.universalimageloader.core.download.BaseImageDownloader.XOR_CONST;

/**
 * Created by pc on 2014/12/23.
 */
public class FileReadUtils {

    /**
     * 以字符为单位读取文件，常用于读文本，数字等类型的文件
     */
    public static void readFileByChars(String fileName) {
        File file = new File(fileName);
        Reader reader = null;
        try {
            System.out.println("以字符为单位读取文件内容，一次读一个字节：");
            // 一次读一个字符
            reader = new InputStreamReader(new FileInputStream(file));
            int tempchar;
            while ((tempchar = reader.read()) != -1) {
                // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
                // 但如果这两个字符分开显示时，会换两次行。
                // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
                if (((char) tempchar) != '\r') {
                    System.out.print((char) tempchar);
                }
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println("以字符为单位读取文件内容，一次读多个字节：");
            // 一次读多个字符
            char[] tempchars = new char[30];
            int charread = 0;
            reader = new InputStreamReader(new FileInputStream(fileName));
            // 读入多个字符到字符数组中，charread为一次读取字符数
            while ((charread = reader.read(tempchars)) != -1) {
                // 同样屏蔽掉\r不显示
                if ((charread == tempchars.length)
                        && (tempchars[tempchars.length - 1] != '\r')) {
                    System.out.print(tempchars);
                } else {
                    for (int i = 0; i < charread; i++) {
                        if (tempchars[i] == '\r') {
                            continue;
                        } else {
                            System.out.print(tempchars[i]);
                        }
                    }
                }
            }

        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
    }

    /**
     * 以行为单位读取文件，常用于读面向行的格式化文件
     */
    public static ArrayList<String> readFileByLines(String fileName) {
        ArrayList<String> result = new ArrayList<String>();
        File file = new File(fileName);
        BufferedReader reader = null;
        try {
            System.out.println("以行为单位读取文件内容，一次读一整行：");
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            int line = 1;
            // 一次读入一行，直到读入null为文件结束
            while ((tempString = reader.readLine()) != null) {
                // 显示行号
                System.out.println("line " + line + ": " + tempString);
                result.add(tempString.trim());
                line++;
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }

        return result;
    }

    public static ArrayList<String> readLines(String fileName) {
        ArrayList<String> lines = new ArrayList<String>();
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream(fileName), "utf-8"));
            String line = null;
            while ((line = br.readLine()) != null) {
                lines.add(line);
                System.out.println(line);
            }
            br.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return lines;
    }

    public static String readDoubanId(String fileName, String name) {
        return readString(fileName, name, "#");
    }

    public static int readVersionCode(String fileName, String name) {
        String s = readString(fileName, name, "@");
        int result = 0;
        try {
            result = Integer.parseInt(s.split("@")[1]);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return result;
    }

    public static CinemaConfig readConfigBySamba(String fileName) {
        CinemaConfig cinemaConfig = new CinemaConfig();
        if (!SambaFileCharge.fileExist(fileName)) {
            return cinemaConfig;
        }
        File file = new File(fileName);
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
                return cinemaConfig;
            }
        }
        String versions = FileReadUtils.readDate(fileName);
        if (!TextUtils.isEmpty(versions)) {
            try {
                cinemaConfig = new Gson().fromJson(versions, new TypeToken<CinemaConfig>() {
                }.getType());
            } catch (JsonSyntaxException e) {
                e.printStackTrace();
            }
        } else {
            cinemaConfig.setDbVersion(-1);
            cinemaConfig.setClassVersion(0);
        }
        return cinemaConfig;
    }

    private static String readString(String fileName, String name, String divide) {
        String lines;
        BufferedReader br;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream(fileName), "utf-8"));
            String line;
            while ((line = br.readLine()) != null) {
                if (line.contains(name)) {
                    if (!TextUtils.isEmpty(line)) {
                        String[] split = line.split(divide);
                        if (split.length >= 2) {
                            if (split[0].equals(name)) {
                                lines = line;
                                return lines;
                            }
                        }
                    }
                }
            }
            br.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 随机读取文件内容
     */
    public static void readFileByRandomAccess(String fileName) {
        RandomAccessFile randomFile = null;
        try {
            System.out.println("随机读取一段文件内容：");
            // 打开一个随机访问文件流，按只读方式
            randomFile = new RandomAccessFile(fileName, "r");
            // 文件长度，字节数
            long fileLength = randomFile.length();
            // 读文件的起始位置
            int beginIndex = (fileLength > 4) ? 4 : 0;
            // 将读文件的开始位置移到beginIndex位置。
            randomFile.seek(beginIndex);
            byte[] bytes = new byte[10];
            int byteread = 0;
            // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
            // 将一次读取的字节数赋给byteread
            while ((byteread = randomFile.read(bytes)) != -1) {
                System.out.write(bytes, 0, byteread);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (randomFile != null) {
                try {
                    randomFile.close();
                } catch (IOException e1) {
                }
            }
        }
    }


    public static String readDate1(String url) {
        try {
            FileReader read = new FileReader(new File(url));
            StringBuffer sb = new StringBuffer();
            char ch[] = new char[1024];
            int d = read.read(ch);
            while (d != -1) {
                String str = new String(ch, 0, d);
                sb.append(str);
                d = read.read(ch);
            }
            read.close();
            return sb.toString();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static int readCount(String url) {
        int count = 0;
        try {
            FileReader read = new FileReader(new File(url));
            StringBuffer sb = new StringBuffer();
            char ch[] = new char[1024];
            int d = read.read(ch);
            while (d != -1) {
                String str = new String(ch, 0, d);
                sb.append(str);
                d = read.read(ch);
            }
            read.close();
            String trim = sb.toString().trim();
//            if (TextUtils.isEmpty(trim)) {
//                return 0;
//            }
            String regex = "^(-?[1-9]\\d*\\.?\\d*)|(-?0\\.\\d*[1-9])|(-?[0])|(-?[0]\\.\\d*)$";
            if (trim.matches(regex)) {
                count = Integer.parseInt(trim);
            } else {
                return 0;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return count;
        }
        return count;
    }

    public static String readDate(String url) {
        if (TextUtils.isEmpty(url)) {
            return null;
        }
        if (!url.endsWith("qnt")) {
            return readDate1(url);
        }
        StringBuffer sb = new StringBuffer();
        try {
            String encoding = "utf-8";
            File file = new File(url);
            if (file.isFile() && file.exists()) { //判断文件是否存在
                FileInputStream in = new FileInputStream(file);
                InputStream inputStream = getInputStream(in, MM_ENCRYPT_STEP);
                assert inputStream != null;
                InputStreamReader read = new InputStreamReader(inputStream, encoding);//考虑到编码格式
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt;
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    sb.append(lineTxt);
                }
                read.close();
            } else {
                System.out.println("找不到指定的文件");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容出错");
            e.printStackTrace();
        }
        return sb.toString();
    }

    public static InputStream getInputStream(InputStream fis, int step) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        InputStream inputStream = null;
        try {
            int read;
            int bytesWritten = 0;
            byte[] buffer = new byte[step];
            while ((read = fis.read(buffer)) > -1) {
                byte[] otherBuffer = new byte[read - 1];
                baos.write(buffer[0] ^ XOR_CONST);
//                System.arraycopy(buffer, 1, otherBuffer, 0, read - 1);
                for (int i = 1; i < read; i++) {
                    otherBuffer[i - 1] = buffer[i];
                }
                baos.write(otherBuffer, bytesWritten, read - 1);
            }
            byte[] byteArray = baos.toByteArray();
            inputStream = new ByteArrayInputStream(byteArray);
            return inputStream;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 附加写入数据
     */
    public static void writeDate(String path, String content) {
        try {
            File file = new File(path);
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();
            BufferedWriter output = new BufferedWriter(new FileWriter(file, true));
            output.write(content);
            output.close();
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }

    public static final int MM_ENCRYPT_STEP = 40;
    public static final int PICTURE_ENCRYPT_STEP = 4 * 1024;

    /**
     * 附加写入数据
     */
    public static void writeDateByEn(String path, String content) {
        FileOutputStream fop = null;
        int step = MM_ENCRYPT_STEP;
        try {
            File file = new File(path);
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();
            fop = new FileOutputStream(file);
            byte[] contentInBytes = content.getBytes();
            encrypt(fop, step, contentInBytes);
            fop.flush();
            fop.close();
            System.out.println("Done");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fop != null) {
                    fop.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 附加写入数据
     */
    public static void writeDateByEncrypt(String path, String content) throws IOException {
        FileOutputStream fop;
        int step = MM_ENCRYPT_STEP;
        File file = new File(path);
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
        fop = new FileOutputStream(file);
        byte[] contentInBytes = content.getBytes();
        encrypt(fop, step, contentInBytes);
        fop.flush();
        fop.close();
        System.out.println("Done");
        fop.close();
    }

    private static void encrypt(FileOutputStream fop, int step, byte[] contentInBytes) throws IOException {
        int cur = 0;
        int read;
        byte[] buffer = new byte[step];
        int length = contentInBytes.length;
        read = length > step ? step : length;
//        System.arraycopy(contentInBytes, cur, buffer, 0, read);
        for (int i = 0; i < read; i++) {
            buffer[i] = contentInBytes[cur + i];
        }
        while (cur < length) {
            fop.write(buffer[0] ^ XOR_CONST);
            byte[] optTypeBuffer = new byte[read - 1];
//            System.arraycopy(buffer, 1, optTypeBuffer, 0, read - 1);
            for (int i = 1; i < read; i++) {
                optTypeBuffer[i - 1] = buffer[i];
            }
            fop.write(optTypeBuffer, 0, read - 1);
            cur += read;
            read = length - cur > step ? step : length - cur;
//            System.arraycopy(contentInBytes, cur, buffer, 0, read);
            for (int i = 0; i < read; i++) {
                buffer[i] = contentInBytes[cur + i];
            }
        }
    }

    /**
     * 附加写入数据
     *
     * @param path
     * @param content
     * @param isAppend 附加还是重写
     */
    public static void writeDates(String path, String content, boolean isAppend) {
        try {
            File file = new File(path);
            if (file.exists()) {
                file.createNewFile();
            }
            BufferedWriter output = new BufferedWriter(new FileWriter(file, isAppend));
            output.write(content);
            output.close();
            Log.d("lovely", "╔════════════════════════════════════════════");
            Log.d("lovely", "╟write success ");
            Log.d("lovely", "╚════════════════════════════════════════════");
        } catch (Exception ex) {
            System.out.println(ex);
            Log.d("lovely", "╔════════════════════════════════════════════");
            Log.d("lovely", "╟write failure ");
            Log.d("lovely", "╚════════════════════════════════════════════");
        }
    }

    /**
     * 写入数据
     */
    public static boolean writeDate1(String path, String content) {

        boolean b = false;
        try {
            File file = new File(path);
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();
            BufferedWriter output = new BufferedWriter(new FileWriter(file));
            output.write(content);
            output.close();
            b = true;
        } catch (Exception ex) {
            System.out.println(ex);
            b = false;
        }
        return b;
    }
}