/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * 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 android.provider.cts;

import static android.provider.DocumentsContract.buildChildDocumentsUri;
import static android.provider.DocumentsContract.buildDocumentUri;
import static android.provider.DocumentsContract.buildDocumentUriUsingTree;
import static android.provider.DocumentsContract.buildRecentDocumentsUri;
import static android.provider.DocumentsContract.buildRootUri;
import static android.provider.DocumentsContract.buildRootsUri;
import static android.provider.DocumentsContract.buildSearchDocumentsUri;
import static android.provider.DocumentsContract.buildTreeDocumentUri;
import static android.provider.DocumentsContract.copyDocument;
import static android.provider.DocumentsContract.createDocument;
import static android.provider.DocumentsContract.createWebLinkIntent;
import static android.provider.DocumentsContract.deleteDocument;
import static android.provider.DocumentsContract.ejectRoot;
import static android.provider.DocumentsContract.findDocumentPath;
import static android.provider.DocumentsContract.getDocumentMetadata;
import static android.provider.DocumentsContract.isChildDocument;
import static android.provider.DocumentsContract.moveDocument;
import static android.provider.DocumentsContract.removeDocument;
import static android.provider.DocumentsContract.renameDocument;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.RETURNS_DEFAULTS;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;

import android.app.PendingIntent;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.res.AssetFileDescriptor;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.graphics.Point;
import android.net.Uri;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.provider.DocumentsContract;
import android.provider.DocumentsContract.Path;
import android.provider.DocumentsProvider;

import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@RunWith(AndroidJUnit4.class)
public class DocumentsContractTest {
    private static final String AUTHORITY = "com.example";

    private static final String DOC_RED = "red";
    private static final String DOC_GREEN = "green";
    private static final String DOC_BLUE = "blue";
    private static final String DOC_RESULT = "result";

    private static final Uri URI_RED = buildDocumentUri(AUTHORITY, DOC_RED);
    private static final Uri URI_GREEN = buildDocumentUri(AUTHORITY, DOC_GREEN);
    private static final Uri URI_BLUE = buildDocumentUri(AUTHORITY, DOC_BLUE);
    private static final Uri URI_RESULT = buildDocumentUri(AUTHORITY, DOC_RESULT);

    private static final String MIME_TYPE = "application/octet-stream";
    private static final String DISPLAY_NAME = "My Test";

    private Context mContext;
    private DocumentsProvider mProvider;
    private ContentResolver mResolver;

    @Before
    public void setUp() {
        mContext = mock(Context.class, RETURNS_DEFAULTS);
        mProvider = mock(DocumentsProvider.class, CALLS_REAL_METHODS);

        final ProviderInfo pi = new ProviderInfo();
        pi.authority = AUTHORITY;
        pi.exported = true;
        pi.grantUriPermissions = true;
        pi.readPermission = android.Manifest.permission.MANAGE_DOCUMENTS;
        pi.writePermission = android.Manifest.permission.MANAGE_DOCUMENTS;
        mProvider.attachInfo(mContext, pi);

        mResolver = ContentResolver.wrap(mProvider);
    }

    @Test
    public void testRootUri() {
        final String auth = "com.example";
        final String rootId = "rootId";
        final PackageManager pm = mock(PackageManager.class);
        final ProviderInfo providerInfo = new ProviderInfo();
        final ResolveInfo resolveInfo = new ResolveInfo();
        final List<ResolveInfo> infoList = new ArrayList<>();

        providerInfo.authority = auth;
        resolveInfo.providerInfo = providerInfo;
        infoList.add(resolveInfo);

        doReturn(pm).when(mContext).getPackageManager();
        doReturn(infoList).when(pm).queryIntentContentProviders(any(Intent.class), anyInt());

        final Uri uri = DocumentsContract.buildRootUri(auth, rootId);

        assertEquals(auth, uri.getAuthority());
        assertEquals(rootId, DocumentsContract.getRootId(uri));
        assertTrue(DocumentsContract.isRootUri(mContext, uri));
    }

    @Test
    public void testRootUri_returnFalse() {
        final String auth = "com.example";
        final String rootId = "rootId";
        final PackageManager pm = mock(PackageManager.class);
        final List<ResolveInfo> infoList = new ArrayList<>();

        doReturn(pm).when(mContext).getPackageManager();
        doReturn(infoList).when(pm).queryIntentContentProviders(any(Intent.class), anyInt());

        final Uri uri = DocumentsContract.buildRootUri(auth, rootId);

        assertEquals(auth, uri.getAuthority());
        assertEquals(rootId, DocumentsContract.getRootId(uri));
        assertFalse(DocumentsContract.isRootUri(mContext, uri));
    }

    @Test
    public void testRootsUri() {
        final String auth = "com.example";
        final PackageManager pm = mock(PackageManager.class);
        final ProviderInfo providerInfo = new ProviderInfo();
        final ResolveInfo resolveInfo = new ResolveInfo();
        final List<ResolveInfo> infoList = new ArrayList<>();

        providerInfo.authority = auth;
        resolveInfo.providerInfo = providerInfo;
        infoList.add(resolveInfo);

        doReturn(pm).when(mContext).getPackageManager();
        doReturn(infoList).when(pm).queryIntentContentProviders(any(Intent.class), anyInt());

        final Uri uri = DocumentsContract.buildRootsUri(auth);
        assertEquals(auth, uri.getAuthority());
        assertTrue(DocumentsContract.isRootsUri(mContext, uri));
    }

    @Test
    public void testRootsUri_returnsFalse() {
        final String auth = "com.example";
        final PackageManager pm = mock(PackageManager.class);
        final List<ResolveInfo> infoList = new ArrayList<>();

        doReturn(pm).when(mContext).getPackageManager();
        doReturn(infoList).when(pm).queryIntentContentProviders(any(Intent.class), anyInt());

        final Uri uri = DocumentsContract.buildRootsUri(auth);
        assertEquals(auth, uri.getAuthority());
        assertFalse(DocumentsContract.isRootsUri(mContext, uri));
    }

    @Test
    public void testDocumentUri() {
        final String auth = "com.example";
        final String docId = "doc:12";

        final Uri uri = DocumentsContract.buildDocumentUri(auth, docId);
        assertEquals(auth, uri.getAuthority());
        assertEquals(docId, DocumentsContract.getDocumentId(uri));
        assertFalse(DocumentsContract.isTreeUri(uri));
    }

    @Test
    public void testTreeDocumentUri() {
        final String auth = "com.example";
        final String treeId = "doc:12";
        final String leafId = "doc:24";

        final Uri treeUri = DocumentsContract.buildTreeDocumentUri(auth, treeId);
        assertEquals(auth, treeUri.getAuthority());
        assertEquals(treeId, DocumentsContract.getTreeDocumentId(treeUri));
        assertTrue(DocumentsContract.isTreeUri(treeUri));

        final Uri leafUri = DocumentsContract.buildDocumentUriUsingTree(treeUri, leafId);
        assertEquals(auth, leafUri.getAuthority());
        assertEquals(treeId, DocumentsContract.getTreeDocumentId(leafUri));
        assertEquals(leafId, DocumentsContract.getDocumentId(leafUri));
        assertTrue(DocumentsContract.isTreeUri(leafUri));
    }

    @Test
    public void testCreateDocument() throws Exception {
        doReturn(DOC_RESULT).when(mProvider).createDocument(DOC_RED, MIME_TYPE, DISPLAY_NAME);
        assertEquals(URI_RESULT, createDocument(mResolver, URI_RED, MIME_TYPE, DISPLAY_NAME));
    }

    @Test
    public void testRenameDocument() throws Exception {
        doReturn(DOC_RESULT).when(mProvider).renameDocument(DOC_RED, DISPLAY_NAME);
        assertEquals(URI_RESULT, renameDocument(mResolver, URI_RED, DISPLAY_NAME));
    }

    @Test
    public void testDeleteDocument() throws Exception {
        doNothing().when(mProvider).deleteDocument(DOC_RED);
        assertEquals(true, deleteDocument(mResolver, URI_RED));
    }

    @Test
    public void testDeleteDocument_Failure() throws Exception {
        doThrow(new RuntimeException()).when(mProvider).deleteDocument(DOC_RED);
        try {
            deleteDocument(mResolver, URI_RED);
            fail();
        } catch (RuntimeException expected) {
        }
    }

    @Test
    public void testCopyDocument() throws Exception {
        doReturn(DOC_RESULT).when(mProvider).copyDocument(DOC_RED, DOC_GREEN);
        assertEquals(URI_RESULT, copyDocument(mResolver, URI_RED, URI_GREEN));
    }

    @Test
    public void testMoveDocument() throws Exception {
        doReturn(DOC_RESULT).when(mProvider).moveDocument(DOC_RED, DOC_GREEN, DOC_BLUE);
        assertEquals(URI_RESULT, moveDocument(mResolver, URI_RED, URI_GREEN, URI_BLUE));
    }

    @Test
    public void testIsChildDocument() throws Exception {
        doReturn(true).when(mProvider).isChildDocument(DOC_RED, DOC_GREEN);
        assertEquals(true, isChildDocument(mResolver, URI_RED, URI_GREEN));
    }

    @Test
    public void testIsChildDocument_Failure() throws Exception {
        doReturn(false).when(mProvider).isChildDocument(DOC_RED, DOC_GREEN);
        assertEquals(false, isChildDocument(mResolver, URI_RED, URI_GREEN));
    }

    @Test
    public void testRemoveDocument() throws Exception {
        doNothing().when(mProvider).removeDocument(DOC_RED, DOC_GREEN);
        assertEquals(true, removeDocument(mResolver, URI_RED, URI_GREEN));
    }

    @Test
    public void testRemoveDocument_Failure() throws Exception {
        doThrow(new RuntimeException()).when(mProvider).removeDocument(DOC_RED, DOC_GREEN);
        try {
            removeDocument(mResolver, URI_RED, URI_GREEN);
            fail();
        } catch (RuntimeException expected) {
        }
    }

    @Test
    public void testEjectRoot() throws Exception {
        doNothing().when(mProvider).ejectRoot("r00t");
        ejectRoot(mResolver, buildRootUri(AUTHORITY, "r00t"));
    }

    @Test
    public void testEjectRoot_Failure() throws Exception {
        doThrow(new RuntimeException()).when(mProvider).ejectRoot("r00t");
        ejectRoot(mResolver, buildRootUri(AUTHORITY, "r00t"));
    }

    @Test
    public void testFindDocumentPath() throws Exception {
        final Path res = new Path(null, Arrays.asList("red", "blue"));

        doReturn(true).when(mProvider).isChildDocument(DOC_RED, DOC_BLUE);
        doReturn(res).when(mProvider).findDocumentPath(DOC_RED, DOC_BLUE);
        assertEquals(res, findDocumentPath(mResolver,
                buildDocumentUriUsingTree(buildTreeDocumentUri(AUTHORITY, DOC_RED), DOC_BLUE)));
    }

    @Test
    public void testCreateWebLinkIntent() throws Exception {
        final IntentSender res = PendingIntent
                .getActivity(InstrumentationRegistry.getTargetContext(), 0,
                        new Intent(Intent.ACTION_VIEW), 0)
                .getIntentSender();

        doReturn(res).when(mProvider).createWebLinkIntent(DOC_RED, Bundle.EMPTY);
        assertEquals(res, createWebLinkIntent(mResolver, URI_RED, Bundle.EMPTY));
    }

    @Test
    public void testGetDocumentMetadata() throws Exception {
        doReturn(Bundle.EMPTY).when(mProvider).getDocumentMetadata(DOC_RED);
        assertEquals(Bundle.EMPTY, getDocumentMetadata(mResolver, URI_RED));
    }

    @Test
    public void testGetDocumentStreamTypes() throws Exception {
        final String[] res = new String[] { MIME_TYPE };

        doReturn(res).when(mProvider).getDocumentStreamTypes(DOC_RED, MIME_TYPE);
        assertArrayEquals(res, mResolver.getStreamTypes(URI_RED, MIME_TYPE));
    }

    @Test
    public void testGetDocumentType() throws Exception {
        doReturn(MIME_TYPE).when(mProvider).getDocumentType(DOC_RED);
        assertEquals(MIME_TYPE, mResolver.getType(URI_RED));
    }

    @Test
    public void testOpenDocument() throws Exception {
        final ParcelFileDescriptor res = ParcelFileDescriptor.open(new File("/dev/null"),
                ParcelFileDescriptor.MODE_READ_ONLY);

        doReturn(res).when(mProvider).openDocument(DOC_RED, "r", null);
        assertEquals(res, mResolver.openFile(URI_RED, "r", null));
    }

    @Test
    public void testOpenDocumentThumbnail() throws Exception {
        final AssetFileDescriptor res = new AssetFileDescriptor(
                ParcelFileDescriptor.open(new File("/dev/null"),
                        ParcelFileDescriptor.MODE_READ_ONLY),
                0, AssetFileDescriptor.UNKNOWN_LENGTH);

        final Point size = new Point(32, 32);
        final Bundle opts = new Bundle();
        opts.putParcelable(ContentResolver.EXTRA_SIZE, size);

        doReturn(res).when(mProvider).openDocumentThumbnail(DOC_RED, size, null);
        assertEquals(res, mResolver.openTypedAssetFile(URI_RED, MIME_TYPE, opts, null));
    }

    @Test
    public void testOpenTypedDocument() throws Exception {
        final AssetFileDescriptor res = new AssetFileDescriptor(
                ParcelFileDescriptor.open(new File("/dev/null"),
                        ParcelFileDescriptor.MODE_READ_ONLY),
                0, AssetFileDescriptor.UNKNOWN_LENGTH);

        doReturn("image/png").when(mProvider).getDocumentType(DOC_RED);
        doReturn(res).when(mProvider).openTypedDocument(DOC_RED, "audio/*", null, null);
        assertEquals(res, mResolver.openTypedAssetFile(URI_RED, "audio/*", null, null));
    }

    @Test
    public void testQueryDocument() throws Exception {
        final Cursor res = new MatrixCursor(new String[0]);

        doReturn(res).when(mProvider).queryDocument(DOC_RED, null);
        assertEquals(res, mResolver.query(URI_RED, null, null, null));
    }

    @Test
    public void testQueryRoots() throws Exception {
        final Cursor res = new MatrixCursor(new String[0]);

        doReturn(res).when(mProvider).queryRoots(null);
        assertEquals(res, mResolver.query(buildRootsUri(AUTHORITY), null, null, null));
    }

    @Test
    public void testQueryChildDocuments() throws Exception {
        final Cursor res = new MatrixCursor(new String[0]);

        doReturn(res).when(mProvider).queryChildDocuments(DOC_RED, null, Bundle.EMPTY);
        assertEquals(res, mResolver.query(buildChildDocumentsUri(AUTHORITY, DOC_RED), null,
                Bundle.EMPTY, null));
    }

    @Test
    public void testQueryRecentDocuments() throws Exception {
        final Cursor res = new MatrixCursor(new String[0]);

        doReturn(res).when(mProvider).queryRecentDocuments(DOC_RED, null, Bundle.EMPTY, null);
        assertEquals(res, mResolver.query(buildRecentDocumentsUri(AUTHORITY, DOC_RED), null,
                Bundle.EMPTY, null));
    }

    @Test
    public void testQuerySearchDocuments() throws Exception {
        final Cursor res = new MatrixCursor(new String[0]);

        doReturn(res).when(mProvider).querySearchDocuments(DOC_RED, null, Bundle.EMPTY);
        assertEquals(res, mResolver.query(buildSearchDocumentsUri(AUTHORITY, DOC_RED, "moo"), null,
                Bundle.EMPTY, null));
    }
}