# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See LICENSE.txt in the project root for
# license information.
# -------------------------------------------------------------------------
import azure.cosmos.documents as documents
from azure.cosmos.aio import CosmosClient
import azure.cosmos.exceptions as exceptions
from azure.cosmos.partition_key import PartitionKey
import urllib3
from requests.utils import DEFAULT_CA_BUNDLE_PATH as CaCertPath

import asyncio
import config

HOST = config.settings['host']
MASTER_KEY = config.settings['master_key']
DATABASE_ID = config.settings['database_id']
CONTAINER_ID = "index-samples"
PARTITION_KEY = PartitionKey(path='/id', kind='Hash')

# A typical container has the following properties within it's indexingPolicy property
#   indexingMode
#   automatic
#   includedPaths
#   excludedPaths
#
# We can toggle 'automatic' to either be True or False depending upon whether we want to have indexing over all columns by default or not.
#
# We can provide options while creating documents. indexingDirective is one such,
# by which we can tell whether it should be included or excluded in the index of the parent container.
# indexingDirective can be either 'Include', 'Exclude' or 'Default'


# To run this Demo, please provide your own CA certs file or download one from
#     http://curl.haxx.se/docs/caextract.html
# Setup the certificate file in .pem format.
# If you still get an SSLError, try disabling certificate verification and suppress warnings

find_entity_by_id_query = {
        "query": "SELECT * FROM r WHERE r.id=@id",
        "parameters": [
            { "name":"@id", "value": id }
        ]
    }

def obtain_client():
    # Try to setup the cacert.pem
    # connection_policy.SSLConfiguration.SSLCaCerts = CaCertPath
    # Else, disable verification
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    return CosmosClient(HOST, MASTER_KEY)


# Query for Entity / Entities
async def query_entities(parent, entity_type, id = None):
    find_entity_by_id_query = {
            "query": "SELECT * FROM r WHERE r.id=@id",
            "parameters": [
                { "name":"@id", "value": id }
            ]
        }
    entities = None
    try:
        if entity_type == 'database':
            if id == None:
                entities = [entity async for entity in parent.list_databases()]
            else:
                entities = [entity async for entity in parent.query_databases(find_entity_by_id_query)]

        elif entity_type == 'container':
            if id == None:
                entities = [entity async for entity in parent.list_containers()]
            else:
                entities = [entity async for entity in parent.query_containers(find_entity_by_id_query)]

        elif entity_type == 'document':
            if id == None:
                entities = [entity async for entity in parent.read_all_items()]
            else:
                entities = [entity async for entity in parent.query_items(find_entity_by_id_query)]
    except exceptions.AzureError as e:
        print("The following error occurred while querying for the entity / entities ", entity_type, id if id != None else "")
        print(e)
        raise
    if id == None:
        return entities
    if entities and len(entities) == 1:
        return entities[0]
    return None


async def delete_container_if_exists(db, container_id):
    try:
        await db.delete_container(container_id)
        print('Container with id \'{0}\' was deleted'.format(container_id))
    except exceptions.CosmosResourceNotFoundError:
        pass
    except exceptions.CosmosHttpResponseError as e:
        if e.status_code == 400:
            print("Bad request for container link", container_id)
        raise


def print_dictionary_items(dict):
    for k, v in dict.items():
        print("{:<15}".format(k), v)
    print()


async def fetch_all_databases(client):
    databases = await query_entities(client, 'database')
    print("-" * 41)
    print("-" * 41)
    for db in databases:
        print_dictionary_items(db)
        print("-" * 41)


async def query_documents_with_custom_query(container, query_with_optional_parameters, message = "Document(s) found by query: "):
    try:
        results = container.query_items(query_with_optional_parameters)
        print(message)
        async for doc in results:
            print(doc)
        return results
    except exceptions.CosmosResourceNotFoundError:
        print("Document doesn't exist")
    except exceptions.CosmosHttpResponseError as e:
        if e.status_code == 400:
            # Can occur when we are trying to query on excluded paths
            print("Bad Request exception occurred: ", e)
            pass
        else:
            raise
    finally:
        print()


async def explicitly_exclude_from_index(db):
    """ The default index policy on a DocumentContainer will AUTOMATICALLY index ALL documents added.
        There may be scenarios where you want to exclude a specific doc from the index even though all other
        documents are being indexed automatically.
        This method demonstrates how to use an index directive to control this

    """
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with default index policy (i.e. automatic = true)
        created_Container = await db.create_container(id=CONTAINER_ID, partition_key=PARTITION_KEY)
        print(created_Container)

        print("\n" + "-" * 25 + "\n1. Container created with index policy")
        properties = await created_Container.read()
        print_dictionary_items(properties["indexingPolicy"])

        # Create a document and query on it immediately.
        # Will work as automatic indexing is still True
        doc = await created_Container.create_item(body={ "id" : "doc1", "orderId" : "order1" })
        print("\n" + "-" * 25 + "Document doc1 created with order1" +  "-" * 25)
        print(doc)

        query = {
                "query": "SELECT * FROM r WHERE r.orderId=@orderNo",
                "parameters": [ { "name":"@orderNo", "value": "order1" } ]
            }
        await query_documents_with_custom_query(created_Container, query)

        # Now, create a document but this time explicitly exclude it from the container using IndexingDirective
        # Then query for that document
        # Should NOT find it, because we excluded it from the index
        # BUT, the document is there and doing a ReadDocument by Id will prove it
        doc2 = await created_Container.create_item(
            body={ "id" : "doc2", "orderId" : "order2" },
            indexing_directive=documents.IndexingDirective.Exclude
        )
        print("\n" + "-" * 25 + "Document doc2 created with order2" +  "-" * 25)
        print(doc2)

        query = {
                "query": "SELECT * FROM r WHERE r.orderId=@orderNo",
                "parameters": [ { "name":"@orderNo", "value": "order2" } ]
                }
        await query_documents_with_custom_query(created_Container, query)

        docRead = await created_Container.read_item(item="doc2", partition_key="doc2")
        print("Document read by ID: \n", docRead["id"])

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def use_manual_indexing(db):
    """The default index policy on a DocumentContainer will AUTOMATICALLY index ALL documents added.
       There may be cases where you can want to turn-off automatic indexing and only selectively add only specific documents to the index.
       This method demonstrates how to control this by setting the value of automatic within indexingPolicy to False

    """
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with manual (instead of automatic) indexing
        created_Container = await db.create_container(
            id=CONTAINER_ID,
            indexing_policy={"automatic" : False},
            partition_key=PARTITION_KEY
        )
        properties = await created_Container.read()
        print(created_Container)

        print("\n" + "-" * 25 + "\n2. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        # Create a document
        # Then query for that document
        # We should find nothing, because automatic indexing on the container level is False
        # BUT, the document is there and doing a ReadDocument by Id will prove it
        doc = await created_Container.create_item(body={ "id" : "doc1", "orderId" : "order1" })
        print("\n" + "-" * 25 + "Document doc1 created with order1" +  "-" * 25)
        print(doc)

        query = {
                "query": "SELECT * FROM r WHERE r.orderId=@orderNo",
                "parameters": [ { "name":"@orderNo", "value": "order1" } ]
            }
        await query_documents_with_custom_query(created_Container, query)

        docRead = await created_Container.read_item(item="doc1", partition_key="doc1")
        print("Document read by ID: \n", docRead["id"])

        # Now create a document, passing in an IndexingDirective saying we want to specifically index this document
        # Query for the document again and this time we should find it because we manually included the document in the index
        doc2 = await created_Container.create_item(
            body={ "id" : "doc2", "orderId" : "order2" },
            indexing_directive=documents.IndexingDirective.Include
        )
        print("\n" + "-" * 25 + "Document doc2 created with order2" +  "-" * 25)
        print(doc2)

        query = {
                "query": "SELECT * FROM r WHERE r.orderId=@orderNo",
                "parameters": [ { "name":"@orderNo", "value": "order2" } ]
            }
        await query_documents_with_custom_query(created_Container, query)

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def exclude_paths_from_index(db):
    """The default behavior is for Cosmos to index every attribute in every document automatically.
       There are times when a document contains large amounts of information, in deeply nested structures
       that you know you will never search on. In extreme cases like this, you can exclude paths from the
       index to save on storage cost, improve write performance and also improve read performance because the index is smaller

       This method demonstrates how to set excludedPaths within indexingPolicy
    """
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        doc_with_nested_structures = {
            "id" : "doc1",
            "foo" : "bar",
            "metaData" : "meta",
            "subDoc" : { "searchable" : "searchable", "nonSearchable" : "value" },
            "excludedNode" : { "subExcluded" : "something",  "subExcludedNode" : { "someProperty" : "value" } }
            }
        container_to_create = { "id" : CONTAINER_ID ,
                                "indexingPolicy" :
                                {
                                    "includedPaths" : [ {'path' : "/*"} ], # Special mandatory path of "/*" required to denote include entire tree
                                    "excludedPaths" : [ {'path' : "/metaData/*"}, # exclude metaData node, and anything under it
                                                        {'path' : "/subDoc/nonSearchable/*"}, # exclude ONLY a part of subDoc
                                                        {'path' : "/\"excludedNode\"/*"} # exclude excludedNode node, and anything under it
                                                      ]
                                    }
                                }
        print(container_to_create)
        print(doc_with_nested_structures)
        # Create a container with the defined properties
        # The effect of the above IndexingPolicy is that only id, foo, and the subDoc/searchable are indexed
        created_Container = await db.create_container(
            id=container_to_create['id'],
            indexing_policy=container_to_create['indexingPolicy'],
            partition_key=PARTITION_KEY
        )
        properties = await created_Container.read()
        print(created_Container)
        print("\n" + "-" * 25 + "\n4. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        # The effect of the above IndexingPolicy is that only id, foo, and the subDoc/searchable are indexed
        doc = await created_Container.create_item(body=doc_with_nested_structures)
        print("\n" + "-" * 25 + "Document doc1 created with nested structures" +  "-" * 25)
        print(doc)

        # Querying for a document on either metaData or /subDoc/subSubDoc/someProperty > fail because these paths were excluded and they raise a BadRequest(400) Exception
        query = {"query": "SELECT * FROM r WHERE r.metaData=@desiredValue", "parameters" : [{ "name":"@desiredValue", "value": "meta" }]}
        await query_documents_with_custom_query(created_Container, query)

        query = {"query": "SELECT * FROM r WHERE r.subDoc.nonSearchable=@desiredValue", "parameters" : [{ "name":"@desiredValue", "value": "value" }]}
        await query_documents_with_custom_query(created_Container, query)

        query = {"query": "SELECT * FROM r WHERE r.excludedNode.subExcludedNode.someProperty=@desiredValue", "parameters" : [{ "name":"@desiredValue", "value": "value" }]}
        await query_documents_with_custom_query(created_Container, query)

        # Querying for a document using foo, or even subDoc/searchable > succeed because they were not excluded
        query = {"query": "SELECT * FROM r WHERE r.foo=@desiredValue", "parameters" : [{ "name":"@desiredValue", "value": "bar" }]}
        await query_documents_with_custom_query(created_Container, query)

        query = {"query": "SELECT * FROM r WHERE r.subDoc.searchable=@desiredValue", "parameters" : [{ "name":"@desiredValue", "value": "searchable" }]}
        await query_documents_with_custom_query(created_Container, query)

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def range_scan_on_hash_index(db):
    """When a range index is not available (i.e. Only hash or no index found on the path), comparisons queries can still
       be performed as scans using Allow scan request headers passed through options

       This method demonstrates how to force a scan when only hash indexes exist on the path

       ===== Warning=====
       This was made an opt-in model by design.
       Scanning is an expensive operation and doing this will have a large impact
       on RequestUnits charged for an operation and will likely result in queries being throttled sooner.
    """
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Force a range scan operation on a hash indexed path
        container_to_create = { "id" : CONTAINER_ID ,
                                "indexingPolicy" :
                                {
                                    "includedPaths" : [ {'path' : "/"} ],
                                    "excludedPaths" : [ {'path' : "/length/*"} ] # exclude length
                                    }
                                }
        created_Container = await db.create_container(
            id=container_to_create['id'],
            indexing_policy=container_to_create['indexingPolicy'],
            partition_key=PARTITION_KEY
        )
        properties = await created_Container.read()
        print(created_Container)
        print("\n" + "-" * 25 + "\n5. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        doc1 = await created_Container.create_item(body={ "id" : "dyn1", "length" : 10, "width" : 5, "height" : 15 })
        doc2 = await created_Container.create_item(body={ "id" : "dyn2", "length" : 7, "width" : 15 })
        doc3 = await created_Container.create_item(body={ "id" : "dyn3", "length" : 2 })
        print("Three docs created with ids : ", doc1["id"], doc2["id"], doc3["id"])

        # Query for length > 5 - fail, this is a range based query on a Hash index only document
        query = { "query": "SELECT * FROM r WHERE r.length > 5" }
        await query_documents_with_custom_query(created_Container, query)

        # Now add IndexingDirective and repeat query
        # expect 200 OK because now we are explicitly allowing scans in a query
        # using the enableScanInQuery directive
        results = created_Container.query_items(
            query,
            enable_scan_in_query=True
        )
        print("Printing documents queried by range by providing enableScanInQuery = True")
        async for doc in results: print(doc["id"])

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def use_range_indexes_on_strings(db):
    """Showing how range queries can be performed even on strings.

    """
    try:
        await delete_container_if_exists(db, CONTAINER_ID)
        # containers = query_entities(client, 'container', parent_link = database_link)
        # print(containers)

        # Use range indexes on strings

        # This is how you can specify a range index on strings (and numbers) for all properties.
        # This is the recommended indexing policy for containers. i.e. precision -1
        #indexingPolicy = {
        #    'indexingPolicy': {
        #        'includedPaths': [
        #            {
        #                'indexes': [
        #                    {
        #                        'kind': documents.IndexKind.Range,
        #                        'dataType': documents.DataType.String,
        #                        'precision': -1
        #                    }
        #                ]
        #            }
        #        ]
        #    }
        #}

        # For demo purposes, we are going to use the default (range on numbers, hash on strings) for the whole document (/* )
        # and just include a range index on strings for the "region".
        container_definition = {
            'id': CONTAINER_ID,
            'indexingPolicy': {
                'includedPaths': [
                    {
                        'path': '/region/?',
                        'indexes': [
                            {
                                'kind': documents.IndexKind.Range,
                                'dataType': documents.DataType.String,
                                'precision': -1
                            }
                        ]
                    },
                    {
                        'path': '/*'
                    }
                ]
            }
        }

        created_Container = await db.create_container(
            id=container_definition['id'],
            indexing_policy=container_definition['indexingPolicy'],
            partition_key=PARTITION_KEY
        )
        properties = await created_Container.read()
        print(created_Container)
        print("\n" + "-" * 25 + "\n6. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        await created_Container.create_item(body={ "id" : "doc1", "region" : "USA" })
        await created_Container.create_item(body={ "id" : "doc2", "region" : "UK" })
        await created_Container.create_item(body={ "id" : "doc3", "region" : "Armenia" })
        await created_Container.create_item(body={ "id" : "doc4", "region" : "Egypt" })

        # Now ordering against region is allowed. You can run the following query
        query = { "query" : "SELECT * FROM r ORDER BY r.region" }
        message = "Documents ordered by region"
        await query_documents_with_custom_query(created_Container, query, message)

        # You can also perform filters against string comparison like >= 'UK'. Note that you can perform a prefix query,
        # the equivalent of LIKE 'U%' (is >= 'U' AND < 'U')
        query = { "query" : "SELECT * FROM r WHERE r.region >= 'U'" }
        message = "Documents with region begining with U"
        await query_documents_with_custom_query(created_Container, query, message)

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def perform_index_transformations(db):
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with default indexing policy
        created_Container = await db.create_container(id=CONTAINER_ID, partition_key=PARTITION_KEY)
        properties = await created_Container.read()
        print(created_Container)

        print("\n" + "-" * 25 + "\n7. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        # Insert some documents
        doc1 = await created_Container.create_item(body={ "id" : "dyn1", "length" : 10, "width" : 5, "height" : 15 })
        doc2 = await created_Container.create_item(body={ "id" : "dyn2", "length" : 7, "width" : 15 })
        doc3 = await created_Container.create_item(body={ "id" : "dyn3", "length" : 2 })
        print("Three docs created with ids : ", doc1["id"], doc2["id"], doc3["id"], " with indexing mode", properties['indexingPolicy']['indexingMode'])

        # Switch to use string & number range indexing with maximum precision.
        print("Changing to string & number range indexing with maximum precision (needed for Order By).")

        properties['indexingPolicy']['includedPaths'][0]['indexes'] = [{
            'kind': documents.IndexKind.Range,
            'dataType': documents.DataType.String,
            'precision': -1
        }]

        created_Container = await db.replace_container(
            container=created_Container.id,
            partition_key=PARTITION_KEY,
            indexing_policy=properties['indexingPolicy']
        )
        properties = await created_Container.read()

        # Check progress and wait for completion - should be instantaneous since we have only a few documents, but larger
        # containers will take time.
        print_dictionary_items(properties["indexingPolicy"])

        # Now exclude a path from indexing to save on storage space.
        print("Now excluding the path /length/ to save on storage space")
        properties['indexingPolicy']['excludedPaths'] = [{"path" : "/length/*"}]

        created_Container = await db.replace_container(
            container=created_Container.id,
            partition_key=PARTITION_KEY,
            indexing_policy=properties['indexingPolicy']
        )
        properties = await created_Container.read()
        print_dictionary_items(properties["indexingPolicy"])

        # Cleanup
        await db.delete_container(created_Container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def perform_multi_orderby_query(db):
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with composite indexes
        indexing_policy = {
            "compositeIndexes": [
                [
                    {
                        "path": "/numberField",
                        "order": "ascending"
                    },
                    {
                        "path": "/stringField",
                        "order": "descending"
                    }
                ],
                [
                    {
                        "path": "/numberField",
                        "order": "descending"
                    },
                    {
                        "path": "/stringField",
                        "order": "ascending"
                    },
                    {
                        "path": "/numberField2",
                        "order": "descending"
                    },
                    {
                        "path": "/stringField2",
                        "order": "ascending"
                    }
                ]
            ]
        }

        created_container = await db.create_container(
            id=CONTAINER_ID,
            indexing_policy=indexing_policy,
            partition_key=PARTITION_KEY
        )
        print(created_container)
        properties = await created_container.read()

        print("\n" + "-" * 25 + "\n8. Container created with index policy")
        print_dictionary_items(properties["indexingPolicy"])

        # Insert some documents
        await created_container.create_item(body={"id": "doc1", "numberField": 1, "stringField": "1", "numberField2": 1, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc2", "numberField": 1, "stringField": "1", "numberField2": 1, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc3", "numberField": 1, "stringField": "1", "numberField2": 2, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc4", "numberField": 1, "stringField": "1", "numberField2": 2, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc5", "numberField": 1, "stringField": "2", "numberField2": 1, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc6", "numberField": 1, "stringField": "2", "numberField2": 1, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc7", "numberField": 1, "stringField": "2", "numberField2": 2, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc8", "numberField": 1, "stringField": "2", "numberField2": 2, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc9", "numberField": 2, "stringField": "1", "numberField2": 1, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc10", "numberField": 2, "stringField": "1", "numberField2": 1, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc11", "numberField": 2, "stringField": "1", "numberField2": 2, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc12", "numberField": 2, "stringField": "1", "numberField2": 2, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc13", "numberField": 2, "stringField": "2", "numberField2": 1, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc14", "numberField": 2, "stringField": "2", "numberField2": 1, "stringField2": "2"})
        await created_container.create_item(body={"id": "doc15", "numberField": 2, "stringField": "2", "numberField2": 2, "stringField2": "1"})
        await created_container.create_item(body={"id": "doc16", "numberField": 2, "stringField": "2", "numberField2": 2, "stringField2": "2"})

        print("Query documents and Order by 1st composite index: Ascending numberField and Descending stringField:")

        query = {
                "query": "SELECT * FROM r ORDER BY r.numberField ASC, r.stringField DESC",
                }
        await query_documents_with_custom_query(created_container, query)

        print("Query documents and Order by inverted 2nd composite index -")
        print("Ascending numberField, Descending stringField, Ascending numberField2, Descending stringField2")

        query = {
                "query": "SELECT * FROM r ORDER BY r.numberField ASC, r.stringField DESC, r.numberField2 ASC, r.stringField2 DESC",
                }
        await query_documents_with_custom_query(created_container, query)

        # Cleanup
        await db.delete_container(created_container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def use_geospatial_indexing_policy(db):
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with geospatial indexes
        indexing_policy = {
            'includedPaths': [
                {'path': '/"Location"/?',
                    'indexes': [
                        {
                            'kind': 'Spatial',
                            'dataType': 'Point'
                        }]
                 },
                {
                    'path': '/'
                }
            ]
        }

        created_container = await db.create_container(
            id=CONTAINER_ID,
            partition_key=PARTITION_KEY,
            indexing_policy=indexing_policy
        )
        properties = await created_container.read()
        print(created_container)

        print("\n" + "-" * 25 + "\n9. Container created with geospatial indexes")
        print_dictionary_items(properties["indexingPolicy"])

        # Create some items
        doc9 = await created_container.create_item(body={"id": "loc1", 'Location': {'type': 'Point', 'coordinates': [20.0, 20.0]}})
        doc9 = await created_container.create_item(body={"id": "loc2", 'Location': {'type': 'Point', 'coordinates': [100.0, 100.0]}})

        # Run ST_DISTANCE queries using the geospatial index
        query = "SELECT * FROM root WHERE (ST_DISTANCE(root.Location, {type: 'Point', coordinates: [20.1, 20]}) < 20000)"
        await query_documents_with_custom_query(created_container, query)

        # Cleanup
        await db.delete_container(created_container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def use_vector_embedding_policy(db):
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with vector embedding policy and vector indexes
        indexing_policy = {
            "vectorIndexes": [
                {"path": "/vector", "type": "quantizedFlat", "quantizationByteSize": 8},
                {"path": "/vector2", "type": "diskANN", "vectorIndexShardKey": ["/city"], "indexingSearchListSize": 50}
            ]
        }
        vector_embedding_policy = {
            "vectorEmbeddings": [
                {
                    "path": "/vector",
                    "dataType": "float32",
                    "dimensions": 256,
                    "distanceFunction": "euclidean"
                },
                {
                    "path": "/vector2",
                    "dataType": "int8",
                    "dimensions": 200,
                    "distanceFunction": "dotproduct"
                }
            ]
        }

        created_container = await db.create_container(
            id=CONTAINER_ID,
            partition_key=PARTITION_KEY,
            indexing_policy=indexing_policy,
            vector_embedding_policy=vector_embedding_policy
        )
        properties = await created_container.read()
        print(created_container)

        print("\n" + "-" * 25 + "\n10. Container created with vector embedding policy and vector indexes")
        print_dictionary_items(properties["indexingPolicy"])
        print_dictionary_items(properties["vectorEmbeddingPolicy"])

        # We define our own get_embeddings() function for the sake of the sample, but you should be using a third
        # party service to generate these properly.
        def get_embeddings(num):
            return [num, num, num]

        # Create some items with vector embeddings
        for i in range(10):
            created_container.create_item({"id": "vector_item" + str(i), "embeddings": get_embeddings(i)})

        # Run vector similarity search queries using VectorDistance
        query = "SELECT TOP 5 c.id,VectorDistance(c.embeddings, [{}]) AS " \
                "SimilarityScore FROM c ORDER BY VectorDistance(c.embeddings, [{}])".format(get_embeddings(1),
                                                                                            get_embeddings(1))
        await query_documents_with_custom_query(created_container, query)

        # Run vector similarity search queries using VectorDistance with specifications
        query = "SELECT TOP 5 c.id,VectorDistance(c.embeddings, [{}], true, {{'dataType': 'float32' ," \
                " 'distanceFunction': 'cosine'}}) AS SimilarityScore FROM c ORDER BY VectorDistance(c.embeddings," \
                " [{}], true, {{'dataType': 'float32', 'distanceFunction': 'cosine'}})".format(get_embeddings(1),
                                                                                               get_embeddings(1))
        await query_documents_with_custom_query(created_container, query)

        # Cleanup
        await db.delete_container(created_container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def use_full_text_policy(db):
    try:
        await delete_container_if_exists(db, CONTAINER_ID)

        # Create a container with full text policy and full text indexes
        indexing_policy = {
            "automatic": True,
            "fullTextIndexes": [
                {"path": "/text1"}
            ]
        }
        full_text_policy = {
            "defaultLanguage": "en-US",
            "fullTextPaths": [
                {
                    "path": "/text1",
                    "language": "en-US"
                },
                {
                    "path": "/text2",
                    "language": "en-US"
                }
            ]
        }

        created_container = await db.create_container(
            id=CONTAINER_ID,
            partition_key=PARTITION_KEY,
            indexing_policy=indexing_policy,
            full_text_policy=full_text_policy
        )
        properties = await created_container.read()
        print(created_container)

        print("\n" + "-" * 25 + "\n11. Container created with full text policy and full text indexes")
        print_dictionary_items(properties["indexingPolicy"])
        print_dictionary_items(properties["fullTextPolicy"])

        # Create some items to use with full text search
        sample_texts = ["Common popular pop music artists include Taylor Swift and The Weekend.",
                        "The weekend is coming up soon, do you have any plans?",
                        "Depending on the artist, their music can be very different.",
                        "Mozart and Beethoven are some of the most recognizable names in classical music.",
                        "Taylor acts in many movies, and is considered a great artist."]

        # Create some items to use with full text search
        for i in range(5):
            created_container.create_item({"id": "full_text_item" + str(i), "text1": sample_texts[i],
                                           "vector": [1, 2, 3]})

        # Run full text search queries using full text score ranking
        query = "SELECT TOP 3 c.text1 FROM c ORDER BY RANK FullTextScore(c.text1, ['artist']))"
        await query_documents_with_custom_query(created_container, query)

        # Run full text search queries using RRF ranking
        query = "SELECT TOP 3 c.text1 FROM c ORDER BY RANK RRF(FullTextScore(c.text1, ['music'])))"
        await query_documents_with_custom_query(created_container, query)

        # Run hybrid search queries using RRF ranking wth vector distances
        query = "SELECT TOP 3 c.text1 FROM c ORDER BY RANK RRF(FullTextScore(c.text1, ['music'])," \
                " VectorDistance(c.vector, [1, 2, 3]))"
        await query_documents_with_custom_query(created_container, query)

        # Cleanup
        db.delete_container(created_container)
        print("\n")
    except exceptions.CosmosResourceExistsError:
        print("Entity already exists")
    except exceptions.CosmosResourceNotFoundError:
        print("Entity doesn't exist")


async def run_sample():
    try:
        async with obtain_client() as client:
            await fetch_all_databases(client)

            # Create database if it doesn't exist already.
            created_db = await client.create_database_if_not_exists(DATABASE_ID)
            print(created_db)

            # 1. Exclude a document from the index
            await explicitly_exclude_from_index(created_db)

            # 2. Use manual (instead of automatic) indexing
            await use_manual_indexing(created_db)

            # 4. Exclude specified document paths from the index
            await exclude_paths_from_index(created_db)

            # 5. Force a range scan operation on a hash indexed path
            await range_scan_on_hash_index(created_db)

            # 6. Use range indexes on strings
            await use_range_indexes_on_strings(created_db)

            # 7. Perform an index transform
            await perform_index_transformations(created_db)

            # 8. Perform Multi Orderby queries using composite indexes
            await perform_multi_orderby_query(created_db)

            # 9. Create and use a geospatial indexing policy
            await use_geospatial_indexing_policy(created_db)

            # 10. Create and use a vector embedding policy
            await use_vector_embedding_policy(created_db)

            # 11. Create and use a full text policy
            await use_full_text_policy(created_db)

    except exceptions.AzureError as e:
        raise e

if __name__ == '__main__':
    asyncio.run(run_sample())