# coding: utf-8

"""

Source Name:   generatepointsfromlines.py

Version:       ArcGIS 10.4/Pro 1.2

Author:        Environmental Systems Research Institute Inc.

Description:   Source for Generate Points From Line geoprocessing tool.

"""

import arcpy

import os

from collections import namedtuple

unit_conversion = dict(CENTIMETERS=0.01, DECIMETERS=0.1, FEET=0.3048,

                       INCHES=0.0254, KILOMETERS=1000.0, METERS=1.0,

                       MILES=1609.347218694438, MILLIMETERS=0.001,

                       NAUTICALMILES=1852.0, POINTS=0.000352777778,

                       UNKNOWN=1.0, YARDS=0.9144)

point_placement = dict(DISTANCE=False, PERCENTAGE=True)

def create_points_from_lines(input_fc, output_fc, spatial_ref, percent=False,

                             dist=True, add_end_points=False):

    """Convert line features to feature class of points

    :param input_fc: Input line features

    :param output_fc: Output point feature class

    :param spatial_ref: The spatial reference of the input

    :param percent: If creating points by percentage (or distance)

    :param dist: The distance used to create points (if percentage == False).

    The distance should be in units of the input (see convert_units)

    :param add_end_points: If True, an extra point will be added from start

    and end point of each line feature

    :return: None

    """

    if percent:

        is_percentage = True

    else:

        is_percentage = False

    # Create output feature class

    arcpy.CreateFeatureclass_management(

        os.path.dirname(output_fc),

        os.path.basename(output_fc),

        geometry_type="POINT",

        spatial_reference=spatial_ref)

    # Add a field to transfer FID from input

    fid_name = 'ORIG_FID'

    arcpy.AddField_management(output_fc, fid_name, 'LONG')

    # Create new points based on input lines

    in_fields = ['SHAPE@', 'OID@']

    out_fields = ['SHAPE@', fid_name]

    with arcpy.da.SearchCursor(input_fc, in_fields) as search_cursor:

        with arcpy.da.InsertCursor(output_fc, out_fields) as insert_cursor:

            for row in search_cursor:

                line = row[0]

                if line:  # if null geometry--skip

                    if line.type == 'polygon':

                        line = line.boundary()

                    if add_end_points:

                        insert_cursor.insertRow([line.firstPoint, row[1]])

                    increment = (percent or dist)

                    cur_length = increment

                    if is_percentage:

                        max_position = 1.0

                    else:

                        max_position = line.length

                    while cur_length < max_position:

                        new_point = line.positionAlongLine(cur_length,

                                                           is_percentage)

                        insert_cursor.insertRow([new_point, row[1]])

                        cur_length += increment

                    if add_end_points:

                        end_point = line.positionAlongLine(1, True)

                        insert_cursor.insertRow([end_point, row[1]])

        try:

            arcpy.JoinField_management(out_fc,

                                       fid_name,

                                       input_fc,

                                       arcpy.Describe(input_fc).OIDFieldName)

        except arcpy.ExecuteError:

            # In unlikely event that JoinField fails, proceed regardless,

            # as spatial and join field are already complete

            pass

    return

def convert_units(dist, param_units, spatial_info):

    """Base unit conversion

    :param dist: Distance

    :param param_units: The units as supplied from tool parameter

    :param spatial_info: arcpy.SpatialReference object

    :return: Distance after converted to new units

    """

    param_units = param_units.upper()

    if param_units in ['', None, 'UNKNOWN']:

        return dist

    else:

        if param_units != 'DECIMALDEGREES':

            p_conversion = unit_conversion[param_units]

        else:

            p_conversion = 111319.8

        try:

            sr_conversion = spatial_info.spatialReference.metersPerUnit

        except AttributeError:

            try:

                input_extent = spatial_info.extent

                centroid = input_extent.polygon.centroid

                point1 = centroid.Y, centroid.X - 0.5

                point2 = centroid.Y, centroid.X + 0.5

                sr_conversion = haversine(point1, point2) * 1000

            except Exception as err:

                # Fallback

                sr_conversion = 111319.8

        return dist * (p_conversion / sr_conversion)

def get_distance_and_units(dist):

    """ Pull distance and units from a linear unit. If units are not

    specified, return UNKNOWN.

    :param dist: Linear units

    :return: Tuple of distance (float) and units (string)

    """

    try:

        dist, units = dist.split(' ', 1)

    except ValueError:

        # ValueError occurs if units are not specified, use 'UNKNOWN'

        units = 'UNKNOWN'

    dist = dist.replace(',', '.')

    return float(dist), units

def haversine(point1, point2):

    """ Calculate the distance between two points on the Earth surface around its curvature.

    Does not account for changes in elevation (datum)

    :param point1 Tuple - Tuple of (Lat, Long) for the first point

    :param point2 Tuple - Tuple of (Lat, Long) for the second point

    :return Float - The distance between the two points about the surface of the globe in kilometers.

    """

    from math import radians, sin, cos, asin, sqrt

    radius_of_earth_km = 6371

    lat1, lng1, lat2, lng2 = list(map(radians, list(point1 + point2)))

    d = sin((lat2 - lat1) / 2) ** 2 + cos(lat1) * cos(lat2) * sin((lng2 - lng1) / 2) ** 2

    return 2 * radius_of_earth_km * asin(sqrt(d))

if __name__ == '__main__':

    in_features = arcpy.GetParameterAsText(0)  # String

    out_fc = arcpy.GetParameterAsText(1)  # String

    use_percent = point_placement[arcpy.GetParameter(2)]  # Str -> Bool

    end_points = arcpy.GetParameter(5)  # Boolean

    describe = arcpy.Describe(in_features)

    spatial_info = namedtuple('spatial_info', 'spatialReference extent')

    sp_info = spatial_info(spatialReference=describe.spatialReference,

                           extent=describe.extent)

    if use_percent:

        percentage = arcpy.GetParameter(4) / 100  # Float

        create_points_from_lines(in_features, out_fc, sp_info.spatialReference,

                                 percent=percentage, add_end_points=end_points)

    else:

        distance = arcpy.GetParameterAsText(3)  # String

        distance, param_linear_units = get_distance_and_units(distance)

        distance = convert_units(distance, param_linear_units,

                                 sp_info)

        create_points_from_lines(in_features, out_fc, sp_info.spatialReference,

                                 dist=distance, add_end_points=end_points)

    try:

        arcpy.AddSpatialIndex_management(out_fc)

    except arcpy.ExecuteError:

        pass