/*
 * Copyright 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.gimi.common.cinema.utils;

import android.text.TextUtils;

import java.io.File;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;


/**
 * Created by wugian on 2016/12/21
 */

public class TimeoutCharge {
    public static boolean ping(String ip) {
        boolean b;
        ExecutorService exec;
        exec = Executors.newCachedThreadPool();
        b = TaskTimeout.execTask(exec, new PingTask(ip), 100);
        exec.shutdown();
        System.out.println("ping End!" + b);
        return b;
    }

    public static boolean fileExists(String path) {
        boolean b;
        ExecutorService exec;
        exec = Executors.newCachedThreadPool();
        b = TaskTimeout.execTask(exec, new FileExistsTask(path), 400);
        exec.shutdown();
        System.out.println("fileExists End!");
        return b;
    }

    private static class TaskTimeout {
        static boolean execTask(ExecutorService exec, Callable<Boolean> task, int timeout) {
            Future<Boolean> future = exec.submit(task);
            Boolean taskResult = null;
//        String failReason = null;
            try {
                // 等待计算结果，最长等待timeout 毫秒，timeout毫秒后中止任务
                taskResult = future.get(timeout, TimeUnit.MILLISECONDS);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
//            failReason = "主线程在等待计算结果时被中断";
            } catch (TimeoutException e) {
                e.printStackTrace();
//            failReason = "主线程等待计算结果超时，因此中断任务线程！";
                exec.shutdownNow();
            }
            if (taskResult == null) {
                return false;
            }
            return taskResult;
        }
    }

    //do what you want to do
    private static class PingTask implements Callable<Boolean> {
        String path;

        PingTask(String path) {
            this.path = path;
        }

        @Override
        public Boolean call() throws Exception {
            return !TextUtils.isEmpty(path) && NetStatusUtils.isAvailableByPing(path);
        }
    }

    //do what you want to do
    private static class FileExistsTask implements Callable<Boolean> {
        String path;

        FileExistsTask(String path) {
            this.path = path;
        }

        @Override
        public Boolean call() throws Exception {
            return !TextUtils.isEmpty(path) && new File(path).exists();
        }
    }
}