package edgeos

import (
	"context"
	"fmt"
	"sync"
)

// GetInterfaces retrieves the interfaces for a specific device.
func (c *Client) GetInterfaces(ctx context.Context, host string) ([]Interface, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out []Interface
	if err := d.do(ctx, "GET", "/api/v1.0/interfaces", nil, &out); err != nil {
		return nil, err
	}

	return out, nil
}

// GetAllInterfaces retrieves interfaces for all devices.
func (c *Client) GetAllInterfaces(ctx context.Context) (map[string][]Interface, error) {
	results := make(map[string][]Interface)
	var mu sync.Mutex
	var wg sync.WaitGroup
    
    // Use a buffered channel or just loop? 
    // Since we return error if any fails? Or partial results?
    // Usually partial results + error or composite error.
    // I will return partial results and the last error for now, or just stop on error?
    // "methods to get ... for either all device"
    // I will implement parallel fetch.

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetInterfaces(ctx, h)
			if err != nil {
				// For now, log error or ignore? 
                // We should probably return an error map or just return what we have?
                // I will just skip failed ones for this implementation or log?
                // I'll return what succeeds.
                // The prompt doesn't specify error handling strategy for "all".
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetDevice retrieves the device info for a specific device.
func (c *Client) GetDevice(ctx context.Context, host string) (*Device, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out Device
	if err := d.do(ctx, "GET", "/api/v1.0/device", nil, &out); err != nil {
		return nil, err
	}

	return &out, nil
}

// GetAllDevices retrieves device info for all devices.
func (c *Client) GetAllDevices(ctx context.Context) (map[string]*Device, error) {
	results := make(map[string]*Device)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetDevice(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetSystem retrieves the system info for a specific device.
func (c *Client) GetSystem(ctx context.Context, host string) (*System, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out System
	if err := d.do(ctx, "GET", "/api/v1.0/system", nil, &out); err != nil {
		return nil, err
	}

	return &out, nil
}

// GetAllSystems retrieves system info for all devices.
func (c *Client) GetAllSystems(ctx context.Context) (map[string]*System, error) {
	results := make(map[string]*System)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetSystem(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetVLANs retrieves the VLANs for a specific device.
func (c *Client) GetVLANs(ctx context.Context, host string) (*VLANs, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out VLANs
	if err := d.do(ctx, "GET", "/api/v1.0/vlans", nil, &out); err != nil {
		return nil, err
	}

	return &out, nil
}

// GetAllVLANs retrieves VLANs for all devices.
func (c *Client) GetAllVLANs(ctx context.Context) (map[string]*VLANs, error) {
	results := make(map[string]*VLANs)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetVLANs(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetServices retrieves the services for a specific device.
func (c *Client) GetServices(ctx context.Context, host string) (*Services, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out Services
	if err := d.do(ctx, "GET", "/api/v1.0/services", nil, &out); err != nil {
		return nil, err
	}

	return &out, nil
}

// GetAllServices retrieves services for all devices.
func (c *Client) GetAllServices(ctx context.Context) (map[string]*Services, error) {
	results := make(map[string]*Services)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetServices(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetStatistics retrieves the statistics for a specific device.
func (c *Client) GetStatistics(ctx context.Context, host string) ([]Statistics, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out []Statistics
	if err := d.do(ctx, "GET", "/api/v1.0/statistics", nil, &out); err != nil {
		return nil, err
	}

	return out, nil
}

// GetAllStatistics retrieves statistics for all devices.
func (c *Client) GetAllStatistics(ctx context.Context) (map[string][]Statistics, error) {
	results := make(map[string][]Statistics)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetStatistics(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}

// GetNeighbors retrieves the neighbors for a specific device.
func (c *Client) GetNeighbors(ctx context.Context, host string) ([]Neighbor, error) {
	d, ok := c.devices[host]
	if !ok {
		return nil, fmt.Errorf("device not found: %s", host)
	}

	var out []Neighbor
	if err := d.do(ctx, "GET", "/api/v1.0/tools/discovery/neighbors", nil, &out); err != nil {
		return nil, err
	}

	return out, nil
}

// GetAllNeighbors retrieves neighbors for all devices.
func (c *Client) GetAllNeighbors(ctx context.Context) (map[string][]Neighbor, error) {
	results := make(map[string][]Neighbor)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for host := range c.devices {
		wg.Add(1)
		go func(h string) {
			defer wg.Done()
			res, err := c.GetNeighbors(ctx, h)
			if err != nil {
				return
			}
			mu.Lock()
			results[h] = res
			mu.Unlock()
		}(host)
	}
	wg.Wait()
	return results, nil
}