import math
import sys

from ij import IJ
from sc.fiji.analyzeSkeleton import AnalyzeSkeleton_

BASIC_NAMES = ['Branches', 'Junctions', 'End-point Voxels',
               'Junction Voxels', 'Slab Voxels', 'Average branch length',
               'Triple Points', 'Quadruple Points', 'Maximum Branch Length']
DETAIL_NAMES = ['Skeleton ID', 'Branch length', 'V1 x', 'V1 y', 'V1 z', 'V2 x',
                'V2 y', 'V2 z', 'Euclidean distance']
OPTIONS = ['edm=Overwrite', 'iterations=1', 'count=1']


def get_euclidean_distance(vertex1, vertex2):
    x1, y1, z1 = get_points(vertex1)
    x2, y2, z2 = get_points(vertex2)
    return math.sqrt(math.pow((x2 - x1), 2) + math.pow((y2 - y1), 2) + math.pow((z2 - z1), 2))


def get_graph_length(graph):
    length = 0
    for edge in graph.getEdges():
        length = length + edge.getLength()
    return length


def get_points(vertex):
    # An array of Point, which has attributes x,y,z.
    point = vertex.getPoints()[0]
    return point.x, point.y, point.z


def get_sorted_edge_lengths(graph):
    # Return graph edges sorted from longest to shortest.
    edges = graph.getEdges()
    edges = sorted(edges, key=lambda edge: edge.getLength(), reverse=True)
    return edges


def get_sorted_graph_lengths(result):
    # Get the separate graphs (skeletons).
    graphs = result.getGraph()
    # Sort graphs from longest to shortest.
    graphs = sorted(graphs, key=lambda g: get_graph_length(g), reverse=True)
    return graphs


def save(result, output, show_detailed_info, calculate_largest_shortest_path, sep='\t'):
    num_trees = int(result.getNumOfTrees())
    outf = open(output, 'wb')
    outf.write('# %s\n' % sep.join(BASIC_NAMES))
    for index in range(num_trees):
        outf.write('%d%s' % (result.getBranches()[index], sep))
        outf.write('%d%s' % (result.getJunctions()[index], sep))
        outf.write('%d%s' % (result.getEndPoints()[index], sep))
        outf.write('%d%s' % (result.getJunctionVoxels()[index], sep))
        outf.write('%d%s' % (result.getSlabs()[index], sep))
        outf.write('%.3f%s' % (result.getAverageBranchLength()[index], sep))
        outf.write('%d%s' % (result.getTriples()[index], sep))
        outf.write('%d%s' % (result.getQuadruples()[index], sep))
        outf.write('%.3f' % result.getMaximumBranchLength()[index])
        if calculate_largest_shortest_path:
            outf.write('%s%.3f%s' % (sep, result.shortestPathList.get(index), sep))
            outf.write('%d%s' % (result.spStartPosition[index][0], sep))
            outf.write('%d%s' % (result.spStartPosition[index][1], sep))
            outf.write('%d\n' % result.spStartPosition[index][2])
        else:
            outf.write('\n')
    if show_detailed_info:
        outf.write('# %s\n' % sep.join(DETAIL_NAMES))
        # The following index is a placeholder for the skeleton ID.
        # The terms "graph" and "skeleton" refer to the same thing.
        # Also, the SkeletonResult.java code states that the
        # private Graph[] graph object is an array of graphs (one
        # per tree).
        for index, graph in enumerate(get_sorted_graph_lengths(result)):
            for edge in get_sorted_edge_lengths(graph):
                vertex1 = edge.getV1()
                x1, y1, z1 = get_points(vertex1)
                vertex2 = edge.getV2()
                x2, y2, z2 = get_points(vertex2)
                outf.write('%d%s' % (index + 1, sep))
                outf.write('%.3f%s' % (edge.getLength(), sep))
                outf.write('%d%s' % (x1, sep))
                outf.write('%d%s' % (y1, sep))
                outf.write('%d%s' % (z1, sep))
                outf.write('%d%s' % (x2, sep))
                outf.write('%d%s' % (y2, sep))
                outf.write('%d%s' % (z2, sep))
                outf.write('%.3f' % get_euclidean_distance(vertex1, vertex2))
                if calculate_largest_shortest_path:
                    # Keep number of separated items the same for each line.
                    outf.write('%s %s' % (sep, sep))
                    outf.write(' %s' % sep)
                    outf.write(' %s' % sep)
                    outf.write(' \n')
                else:
                    outf.write('\n')
    outf.close()


# Fiji Jython interpreter implements Python 2.5 which does not
# provide support for argparse.
error_log = sys.argv[-8]
input = sys.argv[-7]
black_background = sys.argv[-6] == "yes"
prune_cycle_method = sys.argv[-5]
prune_ends = sys.argv[-4] == "yes"
calculate_largest_shortest_path = sys.argv[-3] == "yes"
if calculate_largest_shortest_path:
    BASIC_NAMES.extend(['Longest Shortest Path', 'spx', 'spy', 'spz'])
    DETAIL_NAMES.extend([' ', ' ', ' ', ' '])
show_detailed_info = sys.argv[-2] == "yes"
output = sys.argv[-1]

# Open the input image file.
input_image_plus = IJ.openImage(input)

# Create a copy of the image.
input_image_plus_copy = input_image_plus.duplicate()
image_processor_copy = input_image_plus_copy.getProcessor()

# Set binary options.
options_list = OPTIONS
if black_background:
    options_list.append("black")
options = " ".join(options_list)
IJ.run(input_image_plus_copy, "Options...", options)

# Convert image to binary if necessary.
if not image_processor_copy.isBinary():
    IJ.run(input_image_plus_copy, "Make Binary", "")

# Run AnalyzeSkeleton
analyze_skeleton = AnalyzeSkeleton_()
analyze_skeleton.setup("", input_image_plus_copy)
if prune_cycle_method == 'none':
    prune_index = analyze_skeleton.NONE
elif prune_cycle_method == 'shortest_branch':
    prune_index = analyze_skeleton.SHORTEST_BRANCH
elif prune_cycle_method == 'lowest_intensity_voxel':
    prune_index = analyze_skeleton.LOWEST_INTENSITY_VOXEL
elif prune_cycle_method == 'lowest_intensity_branch':
    prune_index = analyze_skeleton.LOWEST_INTENSITY_BRANCH
result = analyze_skeleton.run(prune_index, prune_ends, calculate_largest_shortest_path, input_image_plus_copy, True, True)
# Save the results.
save(result, output, show_detailed_info, calculate_largest_shortest_path)