# -*- coding: utf-8 -*-
#
#  Copyright 2014 Google Inc. All Rights Reserved.
#
# 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.

"""Simple command-line sample for Google Maps Engine.

This sample code demonstrates use of the Google Maps Engine API.  For more
information on the API, see developers.google.com/maps-engine/documentation/

These samples allow you to
1) List projects you have access to
2) List tables in a given project.
3) Upload a shapefile to create a Table asset.

Usage:
  $ python maps_engine.py [-p project_id] [-s shapefile]

If you do not enter a shapefile, it will upload the included "polygons".

You can also get help on all the command-line flags the program understands
by running:

  $ python maps_engine.py --help

To get detailed log output run:

  $ python maps_engine.py -p 123456 --logging_level=DEBUG
"""

__author__ = "jlivni@google.com (Josh Livni)"

import argparse
import json
import logging
import sys
import time

from googleapiclient import sample_tools
from googleapiclient.http import MediaFileUpload

logging.basicConfig(level=logging.INFO)

# Declare command-line flags.
argparser = argparse.ArgumentParser(add_help=False)
argparser.add_argument("-p", "--project_id", help="optional GME Project ID")
argparser.add_argument("-s", "--shapefile", help="Shapefile (without the .shp)")

SUCCESSFUL_STATUS = ["processed", "complete", "ready"]


class MapsEngineSampleException(Exception):
  """Catch this for failures specific to this sample code."""


def ListProjects(service):
  """List the projects available to the authorized account.

  Args:
    service: The service object built by the Google API Python client library.
  """
  projects = service.projects().list().execute()
  logging.info(json.dumps(projects, indent=2))


def ListTables(service, project_id):
  """List the tables in a given project.

  Args:
    service: The service object built by the Google API Python client library.
    project_id: string, id of the GME project.
  """

  tables = service.tables().list(projectId=project_id).execute()
  logging.info(json.dumps(tables, indent=2))


def UploadShapefile(service, project_id, shapefile_prefix):
  """Upload a shapefile to a given project, and display status when complete.

  Args:
    service: The service object built by the Google API Python client library.
    project_id: string, id of the GME project.
    shapefile_prefix: string, the shapefile without the .shp suffix.

  Returns:
    String id of the table asset.
  """
  # A shapefile is actually a bunch of files; GME requires these four suffixes.
  suffixes = ["shp", "dbf", "prj", "shx"]
  files = []
  for suffix in suffixes:
    files.append({
        "filename": "%s.%s" % (shapefile_prefix, suffix)
    })
  metadata = {
      "projectId": project_id,
      "name": shapefile_prefix,
      "description": "polygons that were uploaded by a script",
      "files": files,
      # You need the string value of a valid shared and published ACL
      # Check the "Access Lists" section of the Maps Engine UI for a list.
      "draftAccessList": "Map Editors",
      "tags": [shapefile_prefix, "auto_upload", "kittens"]
  }

  logging.info("Uploading metadata for %s", shapefile_prefix)
  response = service.tables().upload(body=metadata).execute()
  # We have now created an empty asset.
  table_id = response["id"]

  # And now upload each of the files individually, passing in the table id.
  for suffix in suffixes:
    shapefile = "%s.%s" % (shapefile_prefix, suffix)
    media_body = MediaFileUpload(shapefile, mimetype="application/octet-stream")
    logging.info("uploading %s", shapefile)

    response = service.tables().files().insert(
        id=table_id,
        filename=shapefile,
        media_body=media_body).execute()

  # With all files uploaded, check status of the asset to ensure it's processed.
  CheckAssetStatus(service, "tables", table_id)
  return table_id


def CheckAssetStatus(service, asset_type, asset_id):
  endpoint = getattr(service, asset_type)
  response = endpoint().get(id=asset_id).execute()
  status = response["processingStatus"]
  logging.info("Asset Status: %s", status)
  if status in SUCCESSFUL_STATUS:
    logging.info("asset successfully processed; the id is %s", asset_id)
  else:
    logging.info("Asset %s; will check again in 5 seconds", status)
    time.sleep(5)
    CheckAssetStatus(service, asset_type, asset_id)


def main(argv):
  # Authenticate and construct service.
  service, flags = sample_tools.init(
      argv, "mapsengine", "v1", __doc__, __file__, parents=[argparser],
      scope="https://www.googleapis.com/auth/mapsengine")

  if flags.project_id:
    # ListTables(service, flags.project_id)
    # The example polygons shapefile should be in this directory.
    filename = flags.shapefile or "polygons"
    table_id = UploadShapefile(service, flags.project_id, filename)
    logging.info("Sucessfully created table: %s", table_id)
  else:
    ListProjects(service)
  return


if __name__ == "__main__":
  main(sys.argv)