/*
 * Copyright (c) 2016 wugian
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.xgimi.gimicinema.model;

import android.content.Context;
import android.os.Handler;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import com.gimi.common.cinema.db.NewDBManager;
import com.gimi.common.cinema.model.SambaMsg;
import com.gimi.common.cinema.utils.AdsVideoUtils;
import com.gimi.common.cinema.utils.AppUpdateUtils;
import com.gimi.common.cinema.utils.Utils;
import com.xgimi.gimicinema.BuildConfig;
import com.xgimi.gimicinema.activity.CinemaConfig;
import com.xgimi.gimicinema.appupdate.AppUpgradeManager;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

/**
 * Created by wugian on 2016/9/26
 */
public class UpdateModelImpl implements IUpdateModel {
    private static final String DB_NAME
            = "xgimi_cinema_movie.db";
    private static final String DB_NAME_BACK
            = "xgimi_cinema_movie.db_bak";
    private static final String DB_NAME_HIMEDIA
            = "xgimi_cinema_movie_himedia.db";
    private static String CINEMA_DB_PATH
            = "/data/data/com.xgimi.gimicinema/databases/" + DB_NAME;
    private static String CINEMA_DB_BAK_PATH
            = "/data/data/com.xgimi.gimicinema/databases/" + DB_NAME_BACK;

    private AppUpdateUtils appUpdateUtils;
    private Handler handler = new Handler();

    @Override
    public void updatePoster(Context context) {
        if (appUpdateUtils == null) {
            appUpdateUtils = new AppUpdateUtils(context);
        }
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                appUpdateUtils.updatePoster();
            }
        });
    }

    @Override
    public void updateVideoAdsInfo(Context context) {
        if (appUpdateUtils == null) {
            appUpdateUtils = new AppUpdateUtils(context);
        }
        SambaMsg sambaMsg = Utils.getSambaMsg(context);
        final String rootPath = sambaMsg.getLocalPath();
        final String hash = AdsVideoUtils.getAdsVideoHash(rootPath);

        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                appUpdateUtils.updateVideoInfo(rootPath, hash);
            }
        });
    }

    @Override
    public void updateAppVersion(Context context, boolean bool) {
        final AppUpgradeManager appUpgradeManager = new AppUpgradeManager(context, "com.xgimi.gimicinema", bool);
        if (appUpdateUtils == null) {
            appUpdateUtils = new AppUpdateUtils(context);
        }
        appUpdateUtils.setShowNoUpdate(bool);
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                appUpgradeManager.updateAppVersion();
//                appUpdateUtils.updateAppVersion();
            }
        });
    }

    @Override
    public void updateServerDb(final Context context, final OnCopyDbListener l) {
        resetPackage(context);
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                SambaMsg sambaMsg = Utils.getSambaMsg(context);
                String newPath = UpdateModelImpl.this.getServerPath(sambaMsg);
                File file = new File(newPath);
                if (file.exists()) {
                    file.delete();
                }
                try {
                    Thread.sleep(2 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            /*copyFile*/
                UpdateModelImpl.this.nioTransferCopy(CINEMA_DB_PATH, newPath);
                if (new File(newPath).exists()) {
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            l.onCopyDbSuccess();
                        }
                    });
                } else {
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            l.onCopyDbFailure();
                        }
                    });
                }
            }
        });
    }

    private void resetPackage(Context context) {
        String packageName = context.getPackageName();
        if (!TextUtils.isEmpty(packageName)) {
            CINEMA_DB_PATH = CINEMA_DB_PATH.replace("com.xgimi.gimicinema", packageName);
            CINEMA_DB_BAK_PATH = CINEMA_DB_BAK_PATH.replace("com.xgimi.gimicinema", packageName);
        }
    }

    @Override
    public void updateLocalDb(final Context context, final OnCopyDbListener l) {
        resetPackage(context);
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                SambaMsg sambaMsg = Utils.getSambaMsg(context);
                File file1 = new File(CINEMA_DB_PATH);
                if (file1.exists()) {
                    file1.renameTo(new File(CINEMA_DB_BAK_PATH));
                    try {
                        Thread.sleep(2 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                String newPath = UpdateModelImpl.this.getServerPath(sambaMsg);
                File file = new File(newPath);
                if (file.exists()) {
                /*customBufferStreamCopy*/
                    UpdateModelImpl.this.nioTransferCopy(newPath, CINEMA_DB_PATH);//copyFile(CINEMA_DB_PATH, newPath, l);
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (new File(CINEMA_DB_PATH).exists()) {
//                                new File(CINEMA_DB_BAK_PATH).delete();
                                l.onCopyDbSuccess();
                            } else {
                                l.onCopyDbFailure();
                            }
                        }
                    });
                } else {
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            new File(CINEMA_DB_BAK_PATH).renameTo(
                                    new File(CINEMA_DB_PATH));
                            l.onCopyDbFailure();
                        }
                    });
                }
            }
        });
    }

    @Override
    public void restoreLocalDb(final Context context, final OnRestoreDbListener l) {
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                int size = new NewDBManager(context).query().size();
                if (size > 0) {
                    l.onRestoreSuccess("db size is " + size + " do not need restore");
                    return;
                }
                File file1 = new File(CINEMA_DB_BAK_PATH);
                File newPath = new File(CINEMA_DB_PATH);
                boolean b = false;
                if (file1.exists()) {
                    newPath.delete();
                    b = file1.renameTo(newPath);
                    try {
                        Thread.sleep(2 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (b) {
                    if (newPath.exists()) {
                        l.onRestoreSuccess("restore success");
                        return;
                    }
                }
                l.onRestoreFailure();
            }
        });
    }

    @Override
    public void updateAgentInfo(final Context context) {
        if (appUpdateUtils == null) {
            appUpdateUtils = new AppUpdateUtils(context);
        }
        ThreadUtils.subThread(new ThreadUtils.DoSomeThing() {
            @Override
            public void doSomeThing() {
                appUpdateUtils.updateAgentInfo();
                appUpdateUtils.updateTestGroup();
            }
        });
    }

    @NonNull
    private String getServerPath(SambaMsg sambaMsg) {
        String newPath;
        if (!BuildConfig.MACHINE_TYPE.equals("himedia")) {
            newPath = sambaMsg.getLocalPath() + DB_NAME;
        } else {
            newPath = CinemaConfig.BASIC_ROOT + "/" + DB_NAME_HIMEDIA;
        }
        return newPath;
    }

    public interface OnCopyDbListener {
        void onCopyDbSuccess();

        void onCopyDbFailure();
    }

    public interface OnRestoreDbListener {
        void onRestoreSuccess(String success);

        void onRestoreFailure();
    }
/*
    private void copyFile(String dstPath, String srcPath, OnCopyDbListener l) {
        try {
            int byteSum = 0;
            int byteRead;
            File newFile = new File(dstPath);
            if (!newFile.exists()) {
                newFile.createNewFile();
            }
            File oldFile = new File(srcPath);
            if (oldFile.exists()) { //文件存在时
                InputStream inStream = new FileInputStream(srcPath); //读入原文件
                FileOutputStream fs = new FileOutputStream(dstPath);
                byte[] buffer = new byte[1024];
                while ((byteRead = inStream.read(buffer)) != -1) {
                    byteSum += byteRead; //字节数 文件大小
                    System.out.println(byteSum);
                    fs.write(buffer, 0, byteRead);
                }
                Log.e("copyFile", "176");
                fs.close();
                inStream.close();
                Log.e("copyFile", "179");
            }
        } catch (Exception e) {
//            handler.post(l::onCopyDbFailure);
            System.out.println("复制单个文件操作出错");
            e.printStackTrace();
        }
    }

    private static void customBufferStreamCopy(String source, String target) {
        InputStream fis = null;
        OutputStream fos = null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);
            byte[] buf = new byte[4096];
            int i;
            while ((i = fis.read(buf)) != -1) {
                fos.write(buf, 0, i);
            }
            Log.e("customBufferStreamCopy", "199");
            fis.close();
            fos.close();
            Log.e("customBufferStreamCopy", "202");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }*/

    void nioTransferCopy(String source, String target) {
        FileChannel in = null;
        FileChannel out = null;
        FileInputStream inStream = null;
        FileOutputStream outStream = null;
        try {
            inStream = new FileInputStream(source);
            outStream = new FileOutputStream(target);
            in = inStream.getChannel();
            out = outStream.getChannel();
            in.transferTo(0, in.size(), out);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert (inStream) != null;
                (inStream).close();
                assert (in) != null;
                (in).close();
                (outStream).close();
                assert (out) != null;
                (out).close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}