package services import ( "bytes" "context" "encoding/json" "fmt" "io" "log/slog" "net/http" "strings" "time" "speech-learning-api/internal/config" "speech-learning-api/internal/domain" ) type TeacherAgent interface { NextExercise(ctx context.Context, input domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error) ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error) } type FlowiseTeacher struct { cfg config.Config client *http.Client logger *slog.Logger } func NewFlowiseTeacher(cfg config.Config, logger *slog.Logger) *FlowiseTeacher { return &FlowiseTeacher{ cfg: cfg, client: &http.Client{ Timeout: 30 * time.Second, }, logger: logger, } } func (f *FlowiseTeacher) NextExercise(ctx context.Context, input domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error) { fallback := domain.GeneratedExercise{ ID: "", ExerciseType: "repeat_sentence", TargetLanguage: valueOr(input.TargetLanguage, "en-US"), CEFRLevel: valueOr(input.CEFRLevel, "A1"), ReferenceText: "Hello, my name is Anna.", DisplayPrompt: "Sprich den Satz klar nach.", TTSText: "Hello, my name is Anna.", FocusPoints: []string{"clear rhythm", "final sounds"}, SuccessCriteria: []string{"accuracy above 80"}, ReasonForChoice: "Fallback exercise because Flowise did not return a valid exercise.", Source: "fallback", } payload := map[string]any{ "task": "next_exercise", "user_id": input.UserID, "target_language": input.TargetLanguage, "cefr_level": input.CEFRLevel, "ui_language": input.UILanguage, "profile": input.Profile, "progress": input.Progress, "recent_weak_words": input.RecentWeakWords, "preferred_type": valueOr(input.PreferredType, "repeat_sentence"), "rules": "Generate one A1 English pronunciation exercise. Return valid JSON only with fields: exercise_type, target_language, cefr_level, reference_text, display_prompt, tts_text, focus_points, success_criteria, reason_for_choice.", } return f.askExercise(ctx, payload, input.SessionID, fallback) } func (f *FlowiseTeacher) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) { _ = ctx _ = weakWords return mockFeedback(targetText, result), nil } func (f *FlowiseTeacher) StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error) { _ = ctx _ = targetLanguage _ = cefrLevel return domain.TeacherResponse{ ExerciseType: "conversation", TargetText: "Hello. What is your name?", TeacherFeedback: "Wir starten sehr einfach. Antworte mit: My name is ...", TTSText: "Hello. What is your name?", NextRecommendation: "Antworten: My name is ...", }, nil } func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error) { _ = ctx _ = targetLanguage _ = cefrLevel _ = userText return domain.TeacherResponse{ ExerciseType: "conversation", TargetText: "Nice to meet you. Where are you from?", TeacherFeedback: "Gut. Jetzt uebe einen kurzen Satz mit Herkunft.", TTSText: "Nice to meet you. Where are you from?", NextRecommendation: "Antworten: I am from ...", }, nil } func (f *FlowiseTeacher) askExercise(ctx context.Context, payload any, sessionID string, fallback domain.GeneratedExercise) (domain.GeneratedExercise, error) { if f.cfg.FlowiseChatflow == "" || f.cfg.FlowiseBaseURL == "" { return fallback, nil } body, _ := json.Marshal(payload) reqBody, _ := json.Marshal(map[string]any{ "question": string(body), "overrideConfig": map[string]any{ "sessionId": sessionID, }, }) endpoint := strings.TrimRight(f.cfg.FlowiseBaseURL, "/") + "/api/v1/prediction/" + f.cfg.FlowiseChatflow req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(reqBody)) if err != nil { return fallback, err } req.Header.Set("Content-Type", "application/json") if f.cfg.FlowiseAPIKey != "" { req.Header.Set("Authorization", "Bearer "+f.cfg.FlowiseAPIKey) } resp, err := f.client.Do(req) if err != nil { f.logger.Warn("flowise exercise generation unavailable, using fallback", "error", err) return fallback, nil } defer resp.Body.Close() respBody, err := io.ReadAll(resp.Body) if err != nil { return fallback, err } if resp.StatusCode >= 300 { f.logger.Warn("flowise exercise generation returned error, using fallback", "status", resp.StatusCode, "body", string(respBody)) return fallback, nil } if exercise, ok := parseGeneratedExerciseEnvelope(respBody); ok { exercise.TargetLanguage = valueOr(exercise.TargetLanguage, fallback.TargetLanguage) exercise.CEFRLevel = valueOr(exercise.CEFRLevel, fallback.CEFRLevel) exercise.ExerciseType = valueOr(exercise.ExerciseType, fallback.ExerciseType) exercise.DisplayPrompt = valueOr(exercise.DisplayPrompt, fallback.DisplayPrompt) exercise.TTSText = valueOr(exercise.TTSText, exercise.ReferenceText) exercise.Source = "flowise" return exercise, nil } f.logger.Warn("flowise exercise response not parseable, using fallback", "body", string(respBody)) return fallback, nil } func parseGeneratedExerciseEnvelope(body []byte) (domain.GeneratedExercise, bool) { var envelope struct { Text string `json:"text"` JSON json.RawMessage `json:"json"` } if err := json.Unmarshal(body, &envelope); err == nil { if envelope.Text != "" { if parsed, ok := parseGeneratedExercise(envelope.Text); ok { return parsed, true } } if len(envelope.JSON) > 0 && string(envelope.JSON) != "null" { if parsed, ok := parseGeneratedExerciseJSON(envelope.JSON); ok { return parsed, true } } } return parseGeneratedExercise(string(body)) } func parseGeneratedExercise(value string) (domain.GeneratedExercise, bool) { value = strings.TrimSpace(value) value = strings.TrimPrefix(value, "```json") value = strings.TrimPrefix(value, "```") value = strings.TrimSuffix(value, "```") var out domain.GeneratedExercise if err := json.Unmarshal([]byte(strings.TrimSpace(value)), &out); err != nil { return domain.GeneratedExercise{}, false } return out, strings.TrimSpace(out.ReferenceText) != "" } func parseGeneratedExerciseJSON(value json.RawMessage) (domain.GeneratedExercise, bool) { if parsed, ok := parseGeneratedExercise(string(value)); ok { return parsed, true } var text string if err := json.Unmarshal(value, &text); err != nil { return domain.GeneratedExercise{}, false } return parseGeneratedExercise(text) } func mockFeedback(targetText string, result domain.PronunciationResult) domain.TeacherResponse { weak := "den roten Woertern" for _, word := range result.WordScores { if word.Highlight == "weak" { weak = fmt.Sprintf("'%s'", word.Word) break } } feedback := fmt.Sprintf("Guter Versuch. Uebe jetzt besonders %s. Sprich langsam und halte die Endlaute klar.", weak) if result.OverallScore >= 85 { feedback = "Sehr solide. Wiederhole den Satz einmal etwas natuerlicher und mit ruhigem Rhythmus." } return domain.TeacherResponse{ ExerciseType: "repeat_sentence", TargetText: targetText, TeacherFeedback: feedback, TTSText: targetText, NextRecommendation: "Noch einmal sprechen und auf die markierten Woerter achten.", } }