Tehnična Dokumentacija

public class Post
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public string Title { get; set; }
    public string Body { get; set; }
}

public async Task<List<Post>> GetPostsAsync()
{
    var response = await _client.GetStringAsync(Url);
    var options = new JsonSerializerOptions
    {
        PropertyNameCaseInsensitive = true
    };
    return JsonSerializer.Deserialize<List<Post>>(response, options);
}

public async Task<bool> AddPostAsync(Post post)
{
    var json = JsonSerializer.Serialize(post);
    var content = new StringContent(json, Encoding.UTF8, "application/json");
    var response = await _client.PostAsync(Url, content);
    return response.IsSuccessStatusCode;
}

public async Task<bool> UpdatePostAsync(Post post)
{
    var json = JsonSerializer.Serialize(post);
    var content = new StringContent(json, Encoding.UTF8, "application/json");
    var response = await _client.PutAsync($"{Url}/{post.Id}", content);
    return response.IsSuccessStatusCode;
}

public async Task<bool> DeletePostAsync(int id)
{
    var response = await _client.DeleteAsync($"{Url}/{id}");
    return response.IsSuccessStatusCode;
}

<Grid RowDefinitions="Auto, *, Auto, Auto" Padding="10" RowSpacing="10">
    <!-- Row 0: StatusMessage + Iskanje + Sortiranje -->
    <!-- Row 1: ListView z objavami -->
    <!-- Row 2: Gumb "Dodaj novo objavo" -->
    <!-- Row 3: Gumb "O aplikaciji" -->
</Grid>

<Entry Placeholder="Išči po naslovu..." 
       TextChanged="OnSearchChanged" />

<Picker Title="Sortiraj" 
        SelectedIndexChanged="OnSortChanged">
    <Picker.ItemsSource>
        <x:Array Type="{x:Type x:String}">
            <x:String>A-Z</x:String>
            <x:String>Z-A</x:String>
        </x:Array>
    </Picker.ItemsSource>
</Picker>

<ListView x:Name="PostsListView" 
          ItemSelected="OnPostSelected"
          HasUnevenRows="True">
    <ListView.ItemTemplate>
        <DataTemplate>
            <ViewCell>
                <ViewCell.ContextActions>
                    <MenuItem Text="Izbriši" 
                              IsDestructive="True" 
                              Clicked="OnDeleteClicked" 
                              CommandParameter="{Binding .}"/>
                </ViewCell.ContextActions>
                <StackLayout Padding="10">
                    <Label Text="{Binding Title}" FontAttributes="Bold"/>
                    <Label Text="{Binding Body}" TextColor="Gray"/>
                </StackLayout>
            </ViewCell>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

public ObservableCollection<Post> Posts { get; set; } = new();
private List<Post> _allPosts = new();

protected override async void OnAppearing()
{
    base.OnAppearing();
    if(Posts.Count == 0)
    {
        await LoadData();
    }
}

private void OnSearchChanged(object sender, TextChangedEventArgs e)
{
    var term = e.NewTextValue.ToLower();
    if (string.IsNullOrWhiteSpace(term))
    {
        RefreshList(_allPosts);
    }
    else
    {
        var filtered = _allPosts
            .Where(p => p.Title.ToLower().Contains(term))
            .ToList();
        RefreshList(filtered);
    }
}

private void OnSortChanged(object sender, EventArgs e)
{
    var picker = (Picker)sender;
    int selectedIndex = picker.SelectedIndex;

    var sorted = selectedIndex == 0 
        ? Posts.OrderBy(p => p.Title).ToList()
        : Posts.OrderByDescending(p => p.Title).ToList();

    RefreshList(sorted);
}

private async void OnDeleteClicked(object sender, EventArgs e)
{
    var menuItem = (MenuItem)sender;
    var post = (Post)menuItem.CommandParameter;

    bool success = await _apiService.DeletePostAsync(post.Id);
    if(success)
    {
        Posts.Remove(post);
        _allPosts.Remove(post);
        MyStatusMessage.Show("Uspešno izbrisano!", false);
    }
    else
    {
        MyStatusMessage.Show("Napaka pri brisanju!", true);
    }
}

private async void OnAddClicked(object sender, EventArgs e)
{
    var page = new EditPage(null);
    await Navigation.PushAsync(page);
    
    var newPost = await page._completion.Task;
    if (newPost != null)
    {
        bool success = await _apiService.AddPostAsync(newPost);
        if (success)
        {
            newPost.Id = _allPosts.Max(p => p.Id) + 1;
            _allPosts.Add(newPost);
            Posts.Add(newPost);
            MyStatusMessage.Show("Uspešno dodano!", false);
        }
    }
}

private async void OnPostSelected(object sender, SelectedItemChangedEventArgs e)
{
    if (e.SelectedItem == null) return;
    
    var post = (Post)e.SelectedItem;
    var page = new EditPage(post);
    await Navigation.PushAsync(page);
    
    var updatedPost = await page._completion.Task;
    if (updatedPost != null)
    {
        bool success = await _apiService.UpdatePostAsync(updatedPost);
        if (success)
        {
            post.Title = updatedPost.Title;
            post.Body = updatedPost.Body;
            RefreshList(_allPosts);
            MyStatusMessage.Show("Uspešno posodobljeno!", false);
        }
    }
    
    PostsListView.SelectedItem = null;
}

<VerticalStackLayout Spacing="15" Padding="20">
    <Label Text="Naslov:" />
    <Entry x:Name="EntryTitle" 
           Placeholder="Vnesi naslov" 
           TextChanged="OnTextChanged"/>

    <Label Text="Vsebina:" />
    <Entry x:Name="EntryBody" 
           Placeholder="Vnesi vsebino" 
           HeightRequest="150" 
           TextChanged="OnTextChanged"/>

    <Label x:Name="ErrorLabel" 
           TextColor="Red" 
           IsVisible="False"/>

    <Button Text="Shrani" Clicked="OnSaveClicked"/>
    <Button Text="Prekliči" Clicked="OnCancelClicked"/>
</VerticalStackLayout>

private void OnTextChanged(object sender, TextChangedEventArgs e)
{
    if (string.IsNullOrWhiteSpace(e.NewTextValue))
    {
        ErrorLabel.Text = "Polje ne sme biti prazno!";
        ErrorLabel.IsVisible = true;
    }
    else
    {
        ErrorLabel.IsVisible = false;
    }
}

private async void OnSaveClicked(object sender, EventArgs e)
{
    if(string.IsNullOrWhiteSpace(EntryTitle.Text) || 
       string.IsNullOrWhiteSpace(EntryBody.Text))
    {
        await DisplayAlert("Napaka", "Vsa polja morajo biti izpolnjena!", "OK");
        return;
    }

    _post.Title = EntryTitle.Text;
    _post.Body = EntryBody.Text;

    _completion.SetResult(_post);
    await Navigation.PopAsync();
}

<ContentView xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             x:Class="MAUI.Components.StatusMessage"
             IsVisible="False">
    <Border StrokeShape="RoundRectangle 10" Padding="10">
        <Label x:Name="MessageLabel"
               TextColor="White"
               HorizontalOptions="Center"
               VerticalOptions="Center"
               FontAttributes="Bold"/>
    </Border>
</ContentView>

public async void Show(string message, bool isError)
{
    MessageLabel.Text = message;
    MessageBorder.BackgroundColor = isError ? Colors.Red : Colors.Green;
    this.IsVisible = true;

    await Task.Delay(3000);
    this.IsVisible = false;
}

public class Product
{
    public int Id { get; set; }

    [Required(ErrorMessage = "Naslov je obvezen")]
    public string Title { get; set; } = string.Empty;

    public string Description { get; set; } = string.Empty;

    [Range(0, 10000, ErrorMessage = "Cena mora biti pozitivna")]
    public decimal Price { get; set; }

    public double Rating { get; set; }
    public int Stock { get; set; }
    public string Category { get; set; } = "General";
    public string Thumbnail { get; set; }
}

public async Task<List<Product>> GetProductsAsync()
{
    if (!_soPodatkiNalozeni)
    {
        var response = await _http.GetFromJsonAsync<ProductResponse>("products?limit=10");
        _lokalniProdukti = response.Products;
        _soPodatkiNalozeni = true;
    }

    return _lokalniProdukti;
}

public async Task<Product> GetProductByIdAsync(int id)
{
    var product = _lokalniProdukti.FirstOrDefault(p => p.Id == id);
    return await Task.FromResult(product);
}

public async Task AddProductAsync(Product product)
{
    product.Id = _lokalniProdukti.Max(p => p.Id) + 1;
    product.Thumbnail = "https://cdn.dummyjson.com/product-images/1/thumbnail.jpg";
    _lokalniProdukti.Add(product);
    await Task.CompletedTask;
}

public async Task UpdateProductAsync(int id, Product product)
{
    var obstojeci = _lokalniProdukti.FirstOrDefault(p => p.Id == id);
    if (obstojeci != null)
    {
        obstojeci.Title = product.Title;
        obstojeci.Price = product.Price;
        obstojeci.Stock = product.Stock;
    }
    await Task.CompletedTask;
}

public async Task DeleteProductAsync(int id)
{
    var item = _lokalniProdukti.FirstOrDefault(p => p.Id == id);
    if (item != null)
    {
        _lokalniProdukti.Remove(item);
    }
    await Task.CompletedTask;
}

@page "/products"
@using Blazor.Models
@using Blazor.Services
@inject ProductService ProductService
@inject IJSRuntime JS

<h3>Upravljanje Produktov</h3>

<!-- Iskanje + Sortiranje + Dodaj -->
<div class="row mb-3">
    <div class="col-md-4">
        <input @bind="searchTerm" @bind:event="oninput" />
    </div>
    <div class="col-md-4">
        <button @onclick="SortByPrice">
            Sortiraj po ceni: @(isAscending ? "⬆" : "⬇")
        </button>
    </div>
    <div class="col-md-4">
        <a href="/product/add" class="btn btn-success">Dodaj</a>
    </div>
</div>

<div class="card mb-4">
    <div class="card-header">Vizualizacija podatkov</div>
    <div class="card-body">
        <div class="row">
            <div class="col-md-3">
                <canvas id="chartPrice"></canvas>
            </div>
            <div class="col-md-3">
                <canvas id="chartStock"></canvas>
            </div>
            <div class="col-md-3">
                <canvas id="chartRating"></canvas>
            </div>
            <div class="col-md-3">
                <canvas id="chartValue"></canvas>
            </div>
        </div>
    </div>
</div>

<table class="table table-striped table-hover">
    <thead class="table-dark">
        <tr>
            <th>Slika</th>
            <th>Naziv</th>
            <th>Kategorija</th>
            <th>Cena</th>
            <th>Zaloga</th>
            <th>Akcije</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var p in FilteredProducts)
        {
            <tr>
                <td>
                    <img src="@p.Thumbnail" alt="@p.Title" 
                         style="width: 50px; height: 50px;"/>
                </td>
                <td><strong>@p.Title</strong></td>
                <td>@p.Category</td>
                <td>@p.Price €</td>
                <td>
                    @if(p.Stock < 10) 
                    { 
                        <span class="text-danger">@p.Stock (Nizka!)</span> 
                    } 
                    else 
                    { 
                        <span>@p.Stock</span> 
                    }
                </td>
                <td>
                    <a href="/product/edit/@p.Id">Uredi</a>
                    <button @onclick="() => RequestDelete(p)">Izbriši</button>
                </td>
            </tr>
        }
    </tbody>
</table>

private List<Product> products;
private string searchTerm = "";
private bool isAscending = true;

private IEnumerable<Product> FilteredProducts
{
    get
    {
        if (products == null) return new List<Product>();

        var res = products.AsEnumerable();

        // 1. Filtriranje (Iskanje)
        if (!string.IsNullOrWhiteSpace(searchTerm))
        {
            res = res.Where(p => 
                p.Title.Contains(searchTerm, StringComparison.OrdinalIgnoreCase));
        }

        // 2. Sortiranje
        if (isAscending)
            res = res.OrderBy(p => p.Price);
        else
            res = res.OrderByDescending(p => p.Price);

        return res;
    }
}

protected override async Task OnAfterRenderAsync(bool firstRender)
{
    if (firstRender && products != null)
    {
        await GenerateCharts();
    }
}

private async Task GenerateCharts()
{
    var labels = products.Take(10)
        .Select(p => p.Title.Length > 10 
            ? p.Title.Substring(0, 10) + "..." 
            : p.Title)
        .ToArray();
    
    var top10Products = products.Take(10).ToList();

    // 1. Graf Cen (Line Chart)
    await JS.InvokeVoidAsync("setupChart", "chartPrice", new
    {
        type = "line",
        data = new
        {
            labels = labels,
            datasets = new[] { 
                new { 
                    label = "Cena (€)", 
                    data = top10Products.Select(p => p.Price), 
                    borderColor = "blue", 
                    tension = 0.4 
                } 
            }
        }
    });

    // 2. Graf Zaloge (Bar Chart)
    await JS.InvokeVoidAsync("setupChart", "chartStock", new
    {
        type = "bar",
        data = new
        {
            labels = labels,
            datasets = new[] { 
                new { 
                    label = "Zaloga (kos)", 
                    data = top10Products.Select(p => p.Stock), 
                    backgroundColor = "green" 
                } 
            }
        }
    });

    // 3. Graf Ocen (Bar Chart)
    await JS.InvokeVoidAsync("setupChart", "chartRating", new
    {
        type = "bar",
        data = new
        {
            labels = labels,
            datasets = new[] { 
                new { 
                    label = "Ocena (1-5)", 
                    data = top10Products.Select(p => p.Rating), 
                    backgroundColor = "orange" 
                } 
            }
        }
    });

    // 4. Graf Vrednosti zaloge (Line Chart with fill)
    await JS.InvokeVoidAsync("setupChart", "chartValue", new
    {
        type = "line",
        data = new
        {
            labels = labels,
            datasets = new[] { 
                new { 
                    label = "Vrednost zaloge (€)", 
                    data = top10Products.Select(p => p.Price * p.Stock), 
                    borderColor = "purple", 
                    fill = true,
                    backgroundColor = "rgba(128, 0, 128, 0.2)"
                } 
            }
        }
    });
}

private bool showDeleteDialog = false;
private Product productToDelete;

private void RequestDelete(Product p)
{
    productToDelete = p;
    showDeleteDialog = true;
}

private async Task HandleDeleteConfirmation(bool confirmed)
{
    showDeleteDialog = false;

    if (confirmed && productToDelete != null)
    {
        await ProductService.DeleteProductAsync(productToDelete.Id);
        products = await ProductService.GetProductsAsync();
        
        await JS.InvokeVoidAsync("showAlert", 
            $"Produkt '{productToDelete.Title}' je bil uspešno izbrisan!");
        
        productToDelete = null;
    }
}

@page "/product/add"
@page "/product/edit/{Id:int}"

[Parameter] public int Id { get; set; }

<EditForm Model="product" OnValidSubmit="HandleSubmit">
    <DataAnnotationsValidator />
    <ValidationSummary />

    <div class="mb-3">
        <label>Naziv</label>
        <InputText class="form-control" @bind-Value="product.Title" />
    </div>
    
    <div class="mb-3">
        <label>Cena</label>
        <InputNumber class="form-control" @bind-Value="product.Price" />
    </div>
    
    <div class="mb-3">
        <label>Zaloga</label>
        <InputNumber class="form-control" @bind-Value="product.Stock" />
    </div>

    <button type="submit">Shrani</button>
    <button type="button" @onclick="Cancel">Prekliči</button>
</EditForm>

protected override async Task OnInitializedAsync()
{
    if (Id != 0)
    {
        product = await ProductService.GetProductByIdAsync(Id);
    }
}

private async Task HandleSubmit()
{
    if (Id == 0)
    {
        await ProductService.AddProductAsync(product);
    }
    else
    {
        await ProductService.UpdateProductAsync(Id, product);
    }

    NavManager.NavigateTo("/products");
}

private void Cancel()
{
    NavManager.NavigateTo("/products");
}

@if (Show)
{
    <div class="modal fade show d-block" 
         style="background-color: rgba(0,0,0,0.5);">
        <div class="modal-dialog">
            <div class="modal-content">
                <div class="modal-header">
                    <h5>Potrditev</h5>
                    <button @onclick="Close">×</button>
                </div>
                <div class="modal-body">
                    <p>@Message</p>
                </div>
                <div class="modal-footer">
                    <button @onclick="Close">Prekliči</button>
                    <button @onclick="Confirm">Potrdi</button>
                </div>
            </div>
        </div>
    </div>
}

@code {
    [Parameter] public bool Show { get; set; }
    [Parameter] public string Message { get; set; } = "Ali ste prepričani?";
    [Parameter] public EventCallback<bool> OnConfirmationChange { get; set; }

    private async Task Close() 
        => await OnConfirmationChange.InvokeAsync(false);
    
    private async Task Confirm() 
        => await OnConfirmationChange.InvokeAsync(true);
}

<ConfirmDialog 
    Show="showDeleteDialog" 
    Message="@($"Ali res želite izbrisati produkt '{productToDelete?.Title}'?")"
    OnConfirmationChange="HandleDeleteConfirmation" />

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    window.setupChart = function(canvasId, config) {
        var ctx = document.getElementById(canvasId).getContext('2d');
        
        // Destroy existing chart if exists
        if (window[canvasId + '_chart']) {
            window[canvasId + '_chart'].destroy();
        }
        
        window[canvasId + '_chart'] = new Chart(ctx, config);
    }

    window.showAlert = function(message) {
        alert(message);
    }
</script>

<div class="row">
    <div class="col-md-4">Iskanje</div>
    <div class="col-md-4">Sortiranje</div>
    <div class="col-md-4">Dodaj gumb</div>
</div>

<!-- Grafi -->
<div class="row">
    <div class="col-md-3">Graf 1</div>
    <div class="col-md-3">Graf 2</div>
    <div class="col-md-3">Graf 3</div>
    <div class="col-md-3">Graf 4</div>
</div>

<div class="table-responsive">
    <table class="table table-striped table-hover">
        <!-- Tabela -->
    </table>
</div>

public class GeminiRequest
{
    [JsonPropertyName("contents")]
    public List<GeminiRequestContent> Contents { get; set; }

    [JsonPropertyName("generationConfig")]
    public GeminiGenerationConfig GenerationConfig { get; set; }
}

public class GeminiResponse
{
    [JsonPropertyName("candidates")]
    public List<GeminiCandidate> Candidates { get; set; }
}

public class ProductSuggestion
{
    [JsonPropertyName("name")]
    public string Name { get; set; }

    [JsonPropertyName("description")]
    public string Description { get; set; }

    [JsonPropertyName("estimatedPrice")]
    public decimal EstimatedPrice { get; set; }

    [JsonPropertyName("category")]
    public string Category { get; set; }

    [JsonPropertyName("targetAudience")]
    public string TargetAudience { get; set; }
}

public class ProductSuggestionsResponse
{
    [JsonPropertyName("suggestions")]
    public List<ProductSuggestion> Suggestions { get; set; }

    [JsonPropertyName("summary")]
    public string Summary { get; set; }
}

public async Task<ProductSuggestionsResponse> GetProductSuggestionsAsync(
    string category, string budget, string targetAudience)
{
    // DINAMIČEN PROMPT - sestavljen glede na uporabniški vnos
    string dynamicPrompt = $@"
You are a product recommendation assistant. Based on the following user preferences, 
suggest 3 relevant products.

User Preferences:
- Category: {category}
- Budget: {budget} EUR
- Target Audience: {targetAudience}

IMPORTANT: Respond ONLY with valid JSON in this exact format:
{{
    ""suggestions"": [
        {{
            ""name"": ""Product name"",
            ""description"": ""Brief description"",
            ""estimatedPrice"": 50.00,
            ""category"": ""{category}"",
            ""targetAudience"": ""{targetAudience}""
        }}
    ],
    ""summary"": ""Brief summary of suggestions""
}}

Generate 3 product suggestions that fit the budget and target audience.";
    
    // ... pošlji na API
}

// Pripravi request
var geminiRequest = new GeminiRequest
{
    Contents = new List<GeminiRequestContent>
    {
        new GeminiRequestContent
        {
            Parts = new List<GeminiRequestPart>
            {
                new GeminiRequestPart { Text = dynamicPrompt }
            }
        }
    },
    GenerationConfig = new GeminiGenerationConfig
    {
        Temperature = 0.7,  // Kreativnost modela (0.0 - 1.0)
        MaxOutputTokens = 1024
    }
};

// Pošlji na API - POMEMBNO: API ključ mora biti v headerju!
var request = new HttpRequestMessage(HttpMethod.Post, BASE_URL);
request.Headers.Add("X-goog-api-key", API_KEY);
request.Content = JsonContent.Create(geminiRequest);

var response = await _httpClient.SendAsync(request);

if (!response.IsSuccessStatusCode)
{
    var errorContent = await response.Content.ReadAsStringAsync();
    throw new Exception($"Gemini API error: {response.StatusCode} - {errorContent}");
}

// Pridobi odgovor
var geminiResponse = await response.Content.ReadFromJsonAsync<GeminiResponse>();
var rawText = geminiResponse?.Candidates?.FirstOrDefault()
    ?.Content?.Parts?.FirstOrDefault()?.Text;

// Odstrani markdown code blocks (če jih LLM doda)
var jsonText = rawText.Trim();
if (jsonText.StartsWith("```json"))
{
    jsonText = jsonText.Substring(7);
}
if (jsonText.EndsWith("```"))
{
    jsonText = jsonText.Substring(0, jsonText.Length - 3);
}
jsonText = jsonText.Trim();

// DESERIALIZACIJA v C# objekte
var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true
};
var productSuggestions = JsonSerializer.Deserialize<ProductSuggestionsResponse>(
    jsonText, 
    options
);

return productSuggestions;

<div class="row">
    <div class="col-md-4">
        <label>Kategorija produkta:</label>
        <select @bind="selectedCategory">
            <option value="Elektronika">Elektronika</option>
            <option value="Pohištvo">Pohištvo</option>
            <!-- ... -->
        </select>
    </div>

    <div class="col-md-4">
        <label>Proračun (EUR):</label>
        <input type="number" @bind="budget" />
    </div>

    <div class="col-md-4">
        <label>Ciljna skupina:</label>
        <select @bind="targetAudience">
            <option value="Otroci">Otroci</option>
            <option value="Odrasli">Odrasli</option>
            <!-- ... -->
        </select>
    </div>
</div>

<button @onclick="GetSuggestions" disabled="@isLoading">
    @if (isLoading)
    {
        <span class="spinner-border"></span> Generiranje...
    }
    else
    {
        🚀 Pridobi AI predloge
    }
</button>

@if (suggestions != null)
{
    <div class="card">
        <div class="card-header">✅ AI generiran povzetek</div>
        <div class="card-body">
            <p>@suggestions.Summary</p>
        </div>
    </div>

    <div class="row">
        @foreach (var suggestion in suggestions.Suggestions)
        {
            <div class="col-md-4">
                <div class="card">
                    <h5>@suggestion.Name</h5>
                    <p>@suggestion.Description</p>
                    <h4 class="text-success">@suggestion.EstimatedPrice €</h4>
                    <span class="badge">@suggestion.Category</span>
                    <span class="badge">@suggestion.TargetAudience</span>
                </div>
            </div>
        }
    </div>

    <!-- Raw JSON za debugging -->
    <pre><code>@rawJsonResponse</code></pre>
}

@code {
    private string selectedCategory = "";
    private int budget = 100;
    private string targetAudience = "";
    private bool isLoading = false;
    private ProductSuggestionsResponse suggestions;

    private async Task GetSuggestions()
    {
        // Validacija
        if (string.IsNullOrEmpty(selectedCategory))
        {
            errorMessage = "Prosim izberi kategorijo!";
            return;
        }

        isLoading = true;

        try
        {
            // KLIC GEMINI API
            suggestions = await GeminiService.GetProductSuggestionsAsync(
                selectedCategory, 
                budget.ToString(), 
                targetAudience
            );

            // Shrani JSON za debugging
            rawJsonResponse = JsonSerializer.Serialize(suggestions, 
                new JsonSerializerOptions { WriteIndented = true });
        }
        catch (Exception ex)
        {
            errorMessage = $"Napaka: {ex.Message}";
        }
        finally
        {
            isLoading = false;
        }
    }
}

// ❌ NAROBE - hard-coded ključ v kodi
private const string API_KEY = "Kljucek...";

// ✅ PRAVILNO - iz environment variable ali appsettings.json
private readonly string _apiKey;

public GeminiService(IConfiguration configuration)
{
    _apiKey = configuration["Gemini:ApiKey"];
}

// appsettings.json:
{
  "Gemini": {
    "ApiKey": "YOUR_API_KEY_HERE"
  }
}

private ProductSuggestionsResponse GetMockSuggestions(
    string category, string targetAudience)
{
    return new ProductSuggestionsResponse
    {
        Summary = $"Mock predlogi za '{category}'",
        Suggestions = new List<ProductSuggestion>
        {
            new ProductSuggestion
            {
                Name = $"{category} - Premium",
                Description = "Visokokakovostna opcija",
                EstimatedPrice = 99.99m,
                Category = category,
                TargetAudience = targetAudience
            },
            // ... več predlogov
        }
    };
}