const std = @import("std");
const print = std.debug.print;
const SoundNode = @import("soundnode.zig").SoundNode;
const Allocator = std.mem.Allocator;


pub const Pin = struct {
	
	allocator: Allocator,
	
	src_node: *SoundNode,
	trg_node: *SoundNode,
	
	src_pin: usize = 0,
	trg_pin: usize = 0,
	
	active: u8 = 0,
	
	pub fn create(allocator: Allocator,
					src_node: *SoundNode,
					trg_node: *SoundNode,
					src_pin: usize,
					trg_pin: usize) !*Pin {
	
		const pin = try allocator.create(Pin);
		
		pin.* = .{
			.allocator = allocator,
			.src_node = src_node,
			.trg_node = trg_node,
			.src_pin = src_pin,
			.trg_pin = trg_pin,
			.active = 0,
		};
		
		return pin;
	}
		
	pub fn propagate(self: *Pin) void {
		
		switch (self.src_pin) {
			
			0 => {
				switch (self.trg_pin) {
					0 => {self.trg_node.in_wire += self.src_node.r_amp; },
					1 => {
						const current_tick = self.src_node.fab.current_tick;
						
						const dist: f64 = self.trg_node.distance(self.src_node);
						var b_sample_tick: u32 = 0;
						var n_sample_tick: u32 = 0;
						const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
						
						if (tck > 0) {
							
							b_sample_tick = @intFromFloat( @floor(tck) );
							n_sample_tick = b_sample_tick + 1;
							
							const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
							
							const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
							const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
							
							const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
							const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
							
							self.trg_node.in_air += relayed_r_amp;
						}
					
					},
					6 => {self.trg_node.in6 += self.src_node.r_amp; },
					7 => {self.trg_node.in7 += self.src_node.r_amp; },
					else => {},
				}
			},
	
			1 => {
				switch (self.trg_pin) {
					0 => {self.trg_node.in_wire += self.src_node.out1; },
					1 => {
						const current_tick = self.src_node.fab.current_tick;
						const dist: f64 = self.trg_node.distance(self.src_node);
						var b_sample_tick: u32 = 0;
						var n_sample_tick: u32 = 0;
						const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
						
						if (tck > 0) {
							
							b_sample_tick = @intFromFloat( @floor(tck) );
							n_sample_tick = b_sample_tick + 1;
							
							const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
							
							const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
							const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
							
							const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
							const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
							
							self.trg_node.in_air += relayed_r_amp;
						}
					
					},
					6 => {self.trg_node.in6 += self.src_node.out1; },
					7 => {self.trg_node.in7 += self.src_node.out1; },
					else => {},
				}
			},
	
			6 => {
				switch (self.trg_pin) {
					0 => {self.trg_node.in_wire += self.src_node.out6; },
					1 => {
						const current_tick = self.src_node.fab.current_tick;
						const dist: f64 = self.trg_node.distance(self.src_node);
						var b_sample_tick: u32 = 0;
						var n_sample_tick: u32 = 0;
						const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
						
						if (tck > 0) {
							
							b_sample_tick = @intFromFloat( @floor(tck) );
							n_sample_tick = b_sample_tick + 1;
							
							const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
							
							const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
							const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
							
							const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
							const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
							
							self.trg_node.in_air += relayed_r_amp;
						}
					
					},
					6 => {self.trg_node.in6 += self.src_node.out6; },
					7 => {self.trg_node.in7 += self.src_node.out6; },
					else => {},
				}
			},
	
			7 => {
				switch (self.trg_pin) {
					0 => {self.trg_node.in_wire += self.src_node.out7; },
					1 => {
						const current_tick = self.src_node.fab.current_tick;
						const dist: f64 = self.trg_node.distance(self.src_node);
						var b_sample_tick: u32 = 0;
						var n_sample_tick: u32 = 0;
						const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
						
						if (tck > 0) {
							
							b_sample_tick = @intFromFloat( @floor(tck) );
							n_sample_tick = b_sample_tick + 1;
							
							const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
							
							const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
							const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
							
							const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
							const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
							
							self.trg_node.in_air += relayed_r_amp;
						}
					
					},
					6 => {self.trg_node.in6 += self.src_node.out7; },
					7 => {self.trg_node.in7 += self.src_node.out7; },
					else => {},
				}
			},
	
			2 => {
				switch (self.trg_pin) {
					2 => {self.trg_node.in_gain += self.src_node.gain; },
					3 => {self.trg_node.in_basephase += self.src_node.gain; },
					4 => {self.trg_node.in_phase += self.src_node.gain; },
					8 => {self.trg_node.in8 += self.src_node.gain; },
					9 => {self.trg_node.in9 += self.src_node.gain; },
					else => {},
				}
			},
			
			3 => {
				switch (self.trg_pin) {
					2 => {self.trg_node.in_gain += self.src_node.basephase; },
					3 => {self.trg_node.in_basephase += self.src_node.basephase; },
					4 => {self.trg_node.in_phase += self.src_node.basephase; },
					8 => {self.trg_node.in8 += self.src_node.basephase; },
					9 => {self.trg_node.in9 += self.src_node.basephase; },
					else => {},
				}
			},
			
			4 => {
				switch (self.trg_pin) {
					2 => {self.trg_node.in_gain += self.src_node.phase; },
					3 => {self.trg_node.in_basephase += self.src_node.phase; },
					4 => {self.trg_node.in_phase += self.src_node.phase; },
					8 => {self.trg_node.in8 += self.src_node.phase; },
					9 => {self.trg_node.in9 += self.src_node.phase; },
					else => {},
				}
			},
			
			8 => {
				switch (self.trg_pin) {
					2 => {self.trg_node.in_gain += self.src_node.out8; },
					3 => {self.trg_node.in_basephase += self.src_node.out8; },
					4 => {self.trg_node.in_phase += self.src_node.out8; },
					8 => {self.trg_node.in8 += self.src_node.out8; },
					9 => {self.trg_node.in9 += self.src_node.out8; },
					else => {},
				}
			},
			
			9 => {
				switch (self.trg_pin) {
					2 => {self.trg_node.in_gain += self.src_node.out9; },
					3 => {self.trg_node.in_basephase += self.src_node.out9; },
					4 => {self.trg_node.in_phase += self.src_node.out9; },
					8 => {self.trg_node.in8 += self.src_node.out9; },
					9 => {self.trg_node.in9 += self.src_node.out9; },
					else => {},
				}
			},
			
	
			5 => {
				switch (self.trg_pin) {
					5 => {self.trg_node.in_basefreq += self.src_node.basefreq; },
					10 => {self.trg_node.in10 += self.src_node.basefreq; },
					11 => {self.trg_node.in11 += self.src_node.basefreq; },
					else => {},
				}
			},
			
			10 => {
				switch (self.trg_pin) {
					5 => {self.trg_node.in_basefreq += self.src_node.out10; },
					10 => {self.trg_node.in10 += self.src_node.out10; },
					11 => {self.trg_node.in11 += self.src_node.out10; },
					else => {},
				}
			},
			
			11 => {
				switch (self.trg_pin) {
					5 => {self.trg_node.in_basefreq += self.src_node.out11; },
					10 => {self.trg_node.in10 += self.src_node.out11; },
					11 => {self.trg_node.in11 += self.src_node.out11; },
					else => {},
				}
			},
			
			else => {},
			
		}
	
	}

};