# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

import sys
import logging
from logging.handlers import RotatingFileHandler
import argparse
import time
import requests
import json

# Creates two organizations each with two apps each with three collections each with 100 entities
# Caller must provide a "slug" string which will be used as a prefix for all names
#
# For example, if the slug is mytest then:
#
#   Orgs will be named        mytest_org0 and mytest_org1
#   Org admins will be named  mytest_org0_admin and mytest_org1_admin (both with password test)
#
#   Apps will be named        mytest_org0_app0, mytest_org0_app1 and so on
#   Collections will be named mytest_org0_app0_col0 and so on
#   Entities will be named    mytest_org0_app0_col0_entity and so on
#
# All entities in collection 0 will be connected to entities in collection 1.
# All entities in collection 1 will be connected to entities in collection 2.

def parse_args():
    parser = argparse.ArgumentParser(description="Usergrid Test Data Creation Tool")

    parser.add_argument("--endpoint",
                        help="The endpoint to use for making API requests.",
                        type=str,
                        default="http://localhost:8080")

    parser.add_argument("--user",
                        help="Superuser credentials used to authenticate with Usergrid  <user:pass>",
                        type=str,
                        required=True)

    parser.add_argument("--slug",
                        help="Unique string to be used to name organization, applications and other things create",
                        type=str,
                        required=True)

    my_args = parser.parse_args(sys.argv[1:])

    arg_vars = vars(my_args)
    creds = arg_vars["user"].split(":")
    if len(creds) != 2:
        print("Credentials not properly specified.  Must be '--user <user:pass>'. Exiting...")
        exit_on_error()
    else:
        arg_vars["user"] = creds[0]
        arg_vars["pass"] = creds[1]

    return arg_vars


class Creator:
    def __init__(self):
        self.args = parse_args()
        self.endpoint = self.args["endpoint"]
        self.logger = init_logging(self.__class__.__name__)
        self.admin_user = self.args["user"]
        self.admin_pass = self.args["pass"]
        self.slug = self.args["slug"]

    def run(self):
        self.logger.info("Initializing...")

        if not self.is_endpoint_available():
            exit_on_error("Endpoint is not available, aborting")

        for orgIndex in range(2):
            orgName = self.slug + "_org" + str(orgIndex)
            orgUser = orgName + "_admin"
            orgEmail = orgUser + "@example.com"

            url = self.endpoint + "/management/orgs"
            body = json.dumps({"username":orgUser, "email":orgEmail, "password":"test", "organization":orgName })
            r = requests.post(url=url, data=body, auth=(self.admin_user, self.admin_pass))
            if ( r.status_code >= 400 ):
                print "Error creating organization " + orgName + ": " + r.text
                return

            print "Created org " + orgName

            url = self.endpoint + "/management/token"
            body = json.dumps({"grant_type":"password","username":orgUser,"password":"test"})
            r = requests.post(url=url, data=body)
            if ( r.status_code != 200 ):
                print "Error logging into organization " + orgName + ": " + r.text
                return

            accessToken = r.json()["access_token"]

            for appIndex in range(2):
                appName = orgName + "_app" + str(appIndex)

                url = self.endpoint + "/management/orgs/" + orgName + "/apps?access_token=" + accessToken
                body = json.dumps({"name":appName})
                r = requests.post(url=url, data=body, auth=(self.admin_user, self.admin_pass))
                if ( r.status_code >= 400 ):
                    print "Error creating application" + appName + ": " + r.text
                    return

                print "   Created app: " + orgName + "/" + appName
                appUrl = self.endpoint + "/" + orgName + "/" + appName
                time.sleep(2)

                for userIndex in range(2):
                    userName = appName + "_user" + str(userIndex)
                    email = userName + "@example.com"

                    url = appUrl + "/users?access_token=" + accessToken
                    body = json.dumps({"name":userName, "username":userName, "email":email, "password":"test"})
                    r = requests.post(url=url, data=body)
                    if ( r.status_code >= 400 ):
                        print "Error creating user " + userName + ": " + r.text
                        return

                for colIndex in range(3):
                    colName = appName + "_col" + str(colIndex)
                    print "      Creating collection: " + colName

                    for entityIndex in range(100):
                        entityName = colName + "_entity" + str(entityIndex)

                        url = appUrl + "/" + colName + "s?access_token=" + accessToken
                        body = json.dumps({"name":entityName})
                        r = requests.post(url=url, data=body)
                        if ( r.status_code >= 400 ):
                            print "Error creating entity" + userName + ": " + r.text
                            retur

                # connect entities in collection 0 to collection 1
                for entityIndex in range(100):
                    sourceCollection = appName + "_col0s"
                    sourceName = appName + "_col0_entity" + str(entityIndex)
                    targetName = appName + "_col1_entity" + str(entityIndex)
                    targetType = appName + "_col1"
                    url = appUrl + "/" + sourceCollection + "/" + sourceName + "/has/" + targetType + "/" + targetName
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    if ( r.status_code >= 400 ):
                        print "Error connecting entity " + sourceName + " to " + targetName + ": " + r.text
                        print "url is: " + url
                        return

                # connect entities in collection 1 to collection 2
                for entityIndex in range(100):
                    sourceCollection = appName + "_col1s"
                    sourceName = appName + "_col1_entity" + str(entityIndex)
                    targetName = appName + "_col2_entity" + str(entityIndex)
                    targetType = appName + "_col2"
                    url = appUrl + "/" + sourceCollection + "/" + sourceName + "/has/" + targetType + "/" + targetName
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    r = requests.post(url=url + "?access_token=" + accessToken)
                    if ( r.status_code >= 400 ):
                        print "Error connecting entity " + sourceName + " to " + targetName + ": " + r.text
                        print "url is: " + url
                        return

    def is_endpoint_available(self):

        try:
            r = requests.get(url=self.endpoint+"/status")
            if r.status_code == 200:
                return True
        except requests.exceptions.RequestException as e:
            self.logger.error("Endpoint is unavailable, %s", str(e))
            return False


def exit_on_error(e=""):
    print ("Exiting script due to error: " + str(e))
    sys.exit(1)


def init_logging(name):

    logger = logging.getLogger(name)
    log_file_name = "./create-test-data.log"
    log_formatter = logging.Formatter(fmt="%(asctime)s [%(name)s] %(levelname)s %(message)s",
                                      datefmt="%Y-%m-%d %H:%M:%S")

    rotating_file = logging.handlers.RotatingFileHandler(filename=log_file_name,
                                                         mode="a",
                                                         maxBytes=104857600,
                                                         backupCount=10)
    rotating_file.setFormatter(log_formatter)
    rotating_file.setLevel(logging.INFO)
    logger.addHandler(rotating_file)
    logger.setLevel(logging.INFO)

    stdout_logger = logging.StreamHandler(sys.stdout)
    stdout_logger.setFormatter(log_formatter)
    stdout_logger.setLevel(logging.INFO)
    logger.addHandler(stdout_logger)

    return logger

if __name__ == "__main__":

    creator = Creator()
    creator.run()