import sys, json, random
from math import ceil, pi, sin, cos

sizes = [1.0, 0.9, 0.8, 0.7, 0.3, 0.2, 0.1]
counts = sys.argv[1:8]

base_size = 200
mass_quotient = float(sys.argv[8])
size_quotient = float(sys.argv[9])
subnode_threshold = float(sys.argv[10])

nodes = {}

nodes['n0'] = {
    'width': base_size,
    'height': base_size,
    'color': 'rgba(255,255,255,0.01)',
    'mass': base_size,
    'fixed': True,
    'x': 0,
    'y': 0,
    'image': 'photo' + str(random.randint(1, 5)) + '.jpg',
    'main': True
}
node_count = 1

node_sizes = []
for i in counts:
    node_sizes = node_sizes + [sizes.pop(0)] * int(i)

node_colors = {
    1.0: 'rgba(52,149,255,0.33)',
    0.9: 'rgba(52,149,255,0.33)',
    0.8: 'rgba(52,149,255,0.33)',
    0.7: 'rgba(52,149,255,0.33)',
    0.3: 'rgba(255,0,0,0.33)',
    0.2: 'rgba(255,255,0,0.33)',
    0.1: 'rgba(255,255,255,0.33)'
}

angular_positions = [2 * pi / len(node_sizes) * (n - 1) for n in range(1, len(node_sizes)+1)]
random.shuffle(angular_positions)

edges = {}
edges['n0'] = {}
for node_size in node_sizes:
    node_id = 'n' + str(node_count)
    node_dimension = max(10, int(ceil(base_size * node_size * size_quotient)))
    node_mass = int(ceil(base_size * mass_quotient))
    node_angular_position = angular_positions[node_count-1]
    node_position = { 'x': 0.8 * cos(node_angular_position),
                      'y': 0.8 * sin(node_angular_position) }
    nodes[node_id] = {
        'width': node_dimension,
        'height': node_dimension,
        'mass': node_mass,
        'color': node_colors[node_size],
        'fixed': True,
        'x': node_position['x'],
        'y': node_position['y'],
        'image': 'photo' + str(random.randint(1, 5)) + '.jpg'
    }
    edges['n0'][node_id] = {}
    edges[node_id] = {}
    node_count += 1
    subnode_count = 1
    subnode_sizes = [n for n in node_sizes if (node_size > 0.2) and (random.random() > subnode_threshold)]
    for subnode_size in subnode_sizes:
        subnode_id = node_id + '_' + str(subnode_count)
        subnode_dimension = max(5, int(ceil(base_size * node_size * subnode_size * size_quotient * size_quotient)))
        subnode_mass = int(ceil(base_size * mass_quotient))
        nodes[subnode_id] = {
            'width': subnode_dimension,
            'height': subnode_dimension,
            'mass': subnode_mass,
            'color': node_colors[subnode_size],
            'fixed': True,
            'x': node_position['x'] * (0.995 + random.random() / 100),
            'y': node_position['y'] * (0.995 + random.random() / 100),
            'image': 'photo' + str(random.randint(1, 5)) + '.jpg'
        }
        edges[node_id][subnode_id] = {}
        subnode_count += 1

print json.dumps(
    {
        'repulsion': 2200,
        'stiffness': 900,
        'friction': 0,
        'precision': 0.1,
        'fps': 15,
        'dt': 0.005,
        'gravity': True,
        'nodes': nodes,
        'edges': edges
    }
)