// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.incrementalinstall;

import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileLock;
import java.util.concurrent.Callable;

/** Helpers for dealing with .lock files used during install / first run. */
final class LockFile {
    private static final String TAG = "incrementalinstall";

    private final File mFile;
    private final FileOutputStream mOutputStream;
    private final FileLock mFileLock;

    private LockFile(File file, FileOutputStream outputStream, FileLock fileLock) {
        mFile = file;
        mOutputStream = outputStream;
        mFileLock = fileLock;
    }

    /** Clears the lock file by writing to it (making it non-zero in length); */
    static void clearInstallerLock(File lockFile) throws IOException {
        Log.i(TAG, "Clearing " + lockFile);
        // On Android M+, we can't delete files in /data/local/tmp, so we write to it instead.
        FileOutputStream os = new FileOutputStream(lockFile);
        os.write(1);
        os.close();
    }

    /** Waits for the given file to be non-zero in length. */
    static void waitForInstallerLock(final File file, long timeoutMs) {
        pollingWait(
                new Callable<Boolean>() {
                    @Override
                    public Boolean call() {
                        return !installerLockExists(file);
                    }
                },
                file,
                timeoutMs);
    }

    /** Waits for the given file to be non-zero in length. */
    private static void pollingWait(Callable<Boolean> func, File file, long timeoutMs) {
        long pollIntervalMs = 200;
        for (int i = 0; i < timeoutMs / pollIntervalMs; i++) {
            try {
                if (func.call()) {
                    if (i > 0) {
                        Log.i(TAG, "Finished waiting on lock file: " + file);
                    }
                    return;
                } else if (i == 0) {
                    Log.i(TAG, "Waiting on lock file: " + file);
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            try {
                Thread.sleep(pollIntervalMs);
            } catch (InterruptedException e) {
                // Should never happen.
            }
        }
        throw new RuntimeException("Timed out waiting for lock file: " + file);
    }

    /** Returns whether the given lock file is missing or is in the locked state. */
    static boolean installerLockExists(File file) {
        return !file.exists() || file.length() == 0;
    }

    /**
     * Attempts to acquire a lock for the given file.
     * @return Returns the FileLock if it was acquired, or null otherwise.
     */
    static LockFile acquireRuntimeLock(File file) {
        try {
            FileOutputStream outputStream = new FileOutputStream(file);
            FileLock lock = outputStream.getChannel().tryLock();
            if (lock != null) {
                Log.i(TAG, "Created lock file: " + file);
                return new LockFile(file, outputStream, lock);
            }
            outputStream.close();
        } catch (IOException e) {
            // Do nothing. We didn't get the lock.
            Log.w(TAG, "Exception trying to acquire lock " + file, e);
        }
        return null;
    }

    /** Waits for the given file to not exist. */
    static void waitForRuntimeLock(final File file, long timeoutMs) {
        pollingWait(
                new Callable<Boolean>() {
                    @Override
                    public Boolean call() {
                        return !file.exists();
                    }
                },
                file,
                timeoutMs);
    }

    /** Releases and deletes the lock file. */
    void release() throws IOException {
        Log.i(TAG, "Deleting lock file: " + mFile);
        mFileLock.release();
        mOutputStream.close();
        if (!mFile.delete()) {
            throw new IOException("Failed to delete lock file: " + mFile);
        }
    }
}