Full Examples Python · Swift · Go

// VoicerOnePBX Programmable Voice — Example 1: Auto Attendant (Swift, stdlib only)
//
// The classic phone menu: greet, collect one digit, branch to a department.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
// Uses only system frameworks (Foundation, Network, CryptoKit) — no packages.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 swift main.swift
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/ivr

import Foundation
import Network
import CryptoKit

let SECRET = ProcessInfo.processInfo.environment["VOICER_SECRET"] ?? ""
let BASE   = ProcessInfo.processInfo.environment["VOICER_BASE_URL"] ?? "http://localhost:8080"
let PORT   = UInt16(ProcessInfo.processInfo.environment["PORT"] ?? "8080") ?? 8080

typealias Verb = [String: Any]
typealias CCD = [Verb]

// Where each menu choice sends the caller. `route.to` values are IDs the PBX admin configured.
let department: [String: (phrase: String, transfer: Verb)] = [
    "1": ("Connecting you to sales.",     ["route": ["to": "sales"]]),
    "2": ("Connecting you to support.",   ["route": ["to": "support"]]),
    "0": ("Connecting you to reception.", ["route": ["to": "100"]]),
    "9": ("Connecting your call.",        ["forward": ["to": "+19055550134"]]),
]

// ── The handlers — this is the app ───────────────────────────────────────────

func handleIVR(_ event: [String: Any]) -> CCD {
    [
        ["say": ["text": "Thank you for calling Acme. For sales press 1, for support press 2, "
                       + "for reception press 0, or press 9 to reach our after-hours line."]],
        ["gather": ["numDigits": 1, "timeout": 6, "actionUrl": "\(BASE)/ivr/main"]],
    ]
}

func handleMain(_ event: [String: Any]) -> CCD {
    let reason = event["reason"] as? String ?? ""
    let digits = event["digits"] as? String ?? ""
    if reason == "hangup" { return [] }                          // caller gone
    guard reason != "timeout", let dep = department[digits] else {
        return [["say": ["text": "Sorry, I did not get that."]],
                ["redirect": ["url": "\(BASE)/ivr"]]]
    }
    return [["say": ["text": dep.phrase]], dep.transfer]
}

func route(path: String, event: [String: Any]) -> CCD? {
    switch path {
    case "/ivr":      return handleIVR(event)
    case "/ivr/main": return handleMain(event)
    default:          return nil
    }
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

/// Validate the PBX's HMAC signature: sha256=hex(HMAC-SHA256(secret, ts + "." + body)). See contract §7.
func verify(body: Data, headers: [String: String]) -> Bool {
    if SECRET.isEmpty { return true }                            // dev mode — skipped (warned at startup)
    let ts = headers["x-voicer-timestamp"] ?? ""
    let sent = (headers["x-voicer-signature"] ?? "").replacingOccurrences(of: "sha256=", with: "")
    var msg = Data("\(ts).".utf8); msg.append(body)
    let mac = HMAC<SHA256>.authenticationCode(for: msg, using: SymmetricKey(data: Data(SECRET.utf8)))
    let hexStr = mac.map { String(format: "%02x", $0) }.joined()
    // constant-time compare
    guard hexStr.utf8.count == sent.utf8.count else { return false }
    var diff: UInt8 = 0
    for (a, b) in zip(hexStr.utf8, sent.utf8) { diff |= a ^ b }
    return diff == 0
}

/// Verify → parse event → run the route → serialize the CCD. Returns (status, contentType, body).
func appHandler(path: String, headers: [String: String], body: Data) -> (Int, String, Data) {
    if !verify(body: body, headers: headers) {
        return (403, "application/json", Data(#"{"error":"bad signature"}"#.utf8))
    }
    let event = (try? JSONSerialization.jsonObject(with: body)) as? [String: Any] ?? [:]
    print("  → \(path)  event=\(event["event"] ?? "") digits=\(event["digits"] ?? "")")
    guard let ccd = route(path: path, event: event) else {
        return (404, "application/json", Data(#"{"error":"no such route"}"#.utf8))
    }
    let data = (try? JSONSerialization.data(withJSONObject: ccd)) ?? Data("[]".utf8)
    return (200, "application/json", data)
}

// A minimal HTTP/1.1 server over the Network framework. Reads one request, replies, closes. In production use
// Vapor/Hummingbird and keep only `verify` + the handlers above.
func startServer() {
    let listener = try! NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: PORT)!)
    listener.newConnectionHandler = { conn in
        conn.start(queue: .global())
        var buf = Data()
        func read() {
            conn.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, done, err in
                if let data = data { buf.append(data) }
                if let hdrEnd = buf.range(of: Data("\r\n\r\n".utf8)) {
                    let head = String(data: buf.subdata(in: 0..<hdrEnd.lowerBound), encoding: .utf8) ?? ""
                    let lines = head.components(separatedBy: "\r\n")
                    let reqParts = lines.first?.components(separatedBy: " ") ?? []
                    let path = reqParts.count > 1 ? reqParts[1] : "/"
                    var headers = [String: String]()
                    for l in lines.dropFirst() {
                        if let c = l.firstIndex(of: ":") {
                            headers[l[..<c].trimmingCharacters(in: .whitespaces).lowercased()] =
                                l[l.index(after: c)...].trimmingCharacters(in: .whitespaces)
                        }
                    }
                    let clen = Int(headers["content-length"] ?? "0") ?? 0
                    let bodyStart = hdrEnd.upperBound
                    if buf.count - bodyStart >= clen {
                        let body = buf.subdata(in: bodyStart..<(bodyStart + clen))
                        let (code, ctype, respBody) = appHandler(path: path, headers: headers, body: body)
                        let status = ["200": "200 OK", "403": "403 Forbidden", "404": "404 Not Found"]["\(code)"] ?? "\(code)"
                        var out = Data("HTTP/1.1 \(status)\r\nContent-Type: \(ctype)\r\nContent-Length: \(respBody.count)\r\nConnection: close\r\n\r\n".utf8)
                        out.append(respBody)
                        conn.send(content: out, completion: .contentProcessed { _ in conn.cancel() })
                        return
                    }
                }
                if done || err != nil { conn.cancel(); return }
                read()
            }
        }
        read()
    }
    listener.start(queue: .global())
    print("Auto-attendant sample on :\(PORT)  (control URL → \(BASE)/ivr)")
    if SECRET.isEmpty { print("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).") }
}

startServer()
dispatchMain()

// VoicerOnePBX Programmable Voice — Example 1: Auto Attendant (Go, stdlib only)
//
// The classic phone menu: greet, collect one digit, branch to a department.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 go run main.go
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/ivr
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

var (
	secret = os.Getenv("VOICER_SECRET")                    // must match the PBX endpoint
	base   = envOr("VOICER_BASE_URL", "http://localhost:8080") // how the PBX reaches this app (for actionUrls)
	port   = envOr("PORT", "8080")
)

// A verb is a single-key object; a CCD is an ordered slice of them.
type Verb map[string]any
type CCD []Verb

// Event is the PBX→you request body (only the fields these handlers read).
type Event struct {
	Event    string `json:"event"`
	CallID   string `json:"callId"`
	From     string `json:"from"`
	To       string `json:"to"`
	Digits   string `json:"digits"`
	Speech   string `json:"speech"`
	Reason   string `json:"reason"`
}

// department maps a menu digit to (spoken confirmation, transfer verb).
var department = map[string]struct {
	phrase   string
	transfer Verb
}{
	"1": {"Connecting you to sales.", Verb{"route": map[string]any{"to": "sales"}}},
	"2": {"Connecting you to support.", Verb{"route": map[string]any{"to": "support"}}},
	"0": {"Connecting you to reception.", Verb{"route": map[string]any{"to": "100"}}},
	"9": {"Connecting your call.", Verb{"forward": map[string]any{"to": "+19055550134"}}},
}

// ── The handlers — this is the app ───────────────────────────────────────────

func handleIVR(e Event) CCD {
	return CCD{
		{"say": map[string]any{"text": "Thank you for calling Acme. " +
			"For sales press 1, for support press 2, for reception press 0, " +
			"or press 9 to reach our after-hours line."}},
		{"gather": map[string]any{"numDigits": 1, "timeout": 6, "actionUrl": base + "/ivr/main"}},
	}
}

func handleMain(e Event) CCD {
	if e.Reason == "hangup" {
		return CCD{} // caller gone
	}
	dep, ok := department[e.Digits]
	if e.Reason == "timeout" || !ok {
		return CCD{
			{"say": map[string]any{"text": "Sorry, I did not get that."}},
			{"redirect": map[string]any{"url": base + "/ivr"}},
		}
	}
	return CCD{{"say": map[string]any{"text": dep.phrase}}, dep.transfer}
}

var routes = map[string]func(Event) CCD{
	"/ivr":      handleIVR,
	"/ivr/main": handleMain,
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

// verify checks the PBX's HMAC signature: sha256=hex(HMAC-SHA256(secret, ts + "." + body)).
func verify(body []byte, h http.Header) bool {
	if secret == "" {
		return true // dev mode — verification skipped (warned at startup)
	}
	ts := h.Get("X-Voicer-Timestamp")
	sent := trimPrefix(h.Get("X-Voicer-Signature"), "sha256=")
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(ts + "."))
	mac.Write(body)
	return hmac.Equal([]byte(hex.EncodeToString(mac.Sum(nil))), []byte(sent))
}

func handle(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	if !verify(body, r.Header) {
		http.Error(w, `{"error":"bad signature"}`, http.StatusForbidden)
		return
	}
	fn, ok := routes[r.URL.Path]
	if !ok {
		http.Error(w, `{"error":"no such route"}`, http.StatusNotFound)
		return
	}
	var e Event
	_ = json.Unmarshal(body, &e)
	log.Printf("  → %s  event=%s digits=%q callId=%.8s", r.URL.Path, e.Event, e.Digits, e.CallID)

	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(fn(e)) // ← run the app logic
}

func main() {
	for p := range routes {
		http.HandleFunc(p, handle)
	}
	fmt.Printf("Auto-attendant sample on :%s  (control URL → %s/ivr)\n", port, base)
	if secret == "" {
		fmt.Println("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).")
	}
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func envOr(k, def string) string {
	if v := os.Getenv(k); v != "" {
		return v
	}
	return def
}

func trimPrefix(s, p string) string {
	if len(s) >= len(p) && s[:len(p)] == p {
		return s[len(p):]
	}
	return s
}

// VoicerOnePBX Programmable Voice — Example 2: Phone Survey (Swift, stdlib only)
//
// A multi-step flow that keeps state across callbacks, keyed by the stable callId.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
// Uses only system frameworks (Foundation, Network, CryptoKit) — no packages.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 swift main.swift
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/survey

import Foundation
import Network
import CryptoKit

let SECRET = ProcessInfo.processInfo.environment["VOICER_SECRET"] ?? ""
let BASE   = ProcessInfo.processInfo.environment["VOICER_BASE_URL"] ?? "http://localhost:8080"
let PORT   = UInt16(ProcessInfo.processInfo.environment["PORT"] ?? "8080") ?? 8080

typealias Verb = [String: Any]
typealias CCD = [Verb]

// Per-call state, keyed by callId. In production this is a DB row; the KEY is what matters. Lock-guarded
// because connections are handled concurrently on a global queue.
final class Store {
    private let lock = NSLock()
    private var records: [String: [String: String]] = [:]
    func start(_ id: String, from: String) { lock.lock(); records[id] = ["from": from]; lock.unlock() }
    func set(_ id: String, _ key: String, _ value: String) {
        lock.lock(); if records[id] != nil { records[id]![key] = value }; lock.unlock()
    }
    func exists(_ id: String) -> Bool { lock.lock(); defer { lock.unlock() }; return records[id] != nil }
    func take(_ id: String) -> [String: String]? { lock.lock(); defer { lock.unlock() }; return records.removeValue(forKey: id) }
}
let store = Store()

// ── The handlers — this is the app ───────────────────────────────────────────

func handleStart(_ e: [String: Any]) -> CCD {
    store.start(e["callId"] as? String ?? "", from: e["from"] as? String ?? "")
    return [
        ["say": ["text": "Thanks for taking our two-question survey. On a scale of 1 to 5, how satisfied "
                       + "were you with your call today? Press a number from 1 to 5."]],
        ["gather": ["numDigits": 1, "timeout": 8, "actionUrl": "\(BASE)/survey/q2"]],
    ]
}

func handleQ2(_ e: [String: Any]) -> CCD {
    let id = e["callId"] as? String ?? ""
    guard store.exists(id), (e["reason"] as? String) != "hangup" else { return [] }
    if let d = e["digits"] as? String, !d.isEmpty { store.set(id, "rating", d) }   // ← carried forward by callId
    return [
        ["say": ["text": "Thank you. Would you recommend us to a friend? Press 1 for yes, 2 for no."]],
        ["gather": ["numDigits": 1, "timeout": 8, "actionUrl": "\(BASE)/survey/q3"]],
    ]
}

func handleQ3(_ e: [String: Any]) -> CCD {
    let id = e["callId"] as? String ?? ""
    guard store.exists(id), (e["reason"] as? String) != "hangup" else { return [] }
    store.set(id, "recommend", ["1": "yes", "2": "no"][e["digits"] as? String ?? ""] ?? "unknown")
    return [
        ["say": ["text": "Last thing: leave any comments after the tone, then press pound. "
                       + "Or press pound now to finish."]],
        ["record": ["maxSeconds": 30, "finishOnKey": "#", "transcribe": true, "playBeep": true,
                    "actionUrl": "\(BASE)/survey/done"]],
    ]
}

func handleDone(_ e: [String: Any]) -> CCD {
    if var rec = store.take(e["callId"] as? String ?? "") {
        rec["comment"] = e["transcript"] as? String ?? ""
        print("  ✅ SURVEY COMPLETE: \(rec)")                    // replace with a DB insert
    }
    return [["say": ["text": "Thank you for your feedback. Goodbye."]], ["hangup": [:]]]
}

func route(path: String, event: [String: Any]) -> CCD? {
    switch path {
    case "/survey":      return handleStart(event)
    case "/survey/q2":   return handleQ2(event)
    case "/survey/q3":   return handleQ3(event)
    case "/survey/done": return handleDone(event)
    default:             return nil
    }
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

func verify(body: Data, headers: [String: String]) -> Bool {
    if SECRET.isEmpty { return true }
    let ts = headers["x-voicer-timestamp"] ?? ""
    let sent = (headers["x-voicer-signature"] ?? "").replacingOccurrences(of: "sha256=", with: "")
    var msg = Data("\(ts).".utf8); msg.append(body)
    let mac = HMAC<SHA256>.authenticationCode(for: msg, using: SymmetricKey(data: Data(SECRET.utf8)))
    let hexStr = mac.map { String(format: "%02x", $0) }.joined()
    guard hexStr.utf8.count == sent.utf8.count else { return false }
    var diff: UInt8 = 0
    for (a, b) in zip(hexStr.utf8, sent.utf8) { diff |= a ^ b }
    return diff == 0
}

func appHandler(path: String, headers: [String: String], body: Data) -> (Int, String, Data) {
    if !verify(body: body, headers: headers) {
        return (403, "application/json", Data(#"{"error":"bad signature"}"#.utf8))
    }
    let event = (try? JSONSerialization.jsonObject(with: body)) as? [String: Any] ?? [:]
    print("  → \(path)  event=\(event["event"] ?? "") digits=\(event["digits"] ?? "")")
    guard let ccd = route(path: path, event: event) else {
        return (404, "application/json", Data(#"{"error":"no such route"}"#.utf8))
    }
    let data = (try? JSONSerialization.data(withJSONObject: ccd)) ?? Data("[]".utf8)
    return (200, "application/json", data)
}

func startServer() {
    let listener = try! NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: PORT)!)
    listener.newConnectionHandler = { conn in
        conn.start(queue: .global())
        var buf = Data()
        func read() {
            conn.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, done, err in
                if let data = data { buf.append(data) }
                if let hdrEnd = buf.range(of: Data("\r\n\r\n".utf8)) {
                    let head = String(data: buf.subdata(in: 0..<hdrEnd.lowerBound), encoding: .utf8) ?? ""
                    let lines = head.components(separatedBy: "\r\n")
                    let reqParts = lines.first?.components(separatedBy: " ") ?? []
                    let path = reqParts.count > 1 ? reqParts[1] : "/"
                    var headers = [String: String]()
                    for l in lines.dropFirst() {
                        if let c = l.firstIndex(of: ":") {
                            headers[l[..<c].trimmingCharacters(in: .whitespaces).lowercased()] =
                                l[l.index(after: c)...].trimmingCharacters(in: .whitespaces)
                        }
                    }
                    let clen = Int(headers["content-length"] ?? "0") ?? 0
                    let bodyStart = hdrEnd.upperBound
                    if buf.count - bodyStart >= clen {
                        let body = buf.subdata(in: bodyStart..<(bodyStart + clen))
                        let (code, ctype, respBody) = appHandler(path: path, headers: headers, body: body)
                        let status = ["200": "200 OK", "403": "403 Forbidden", "404": "404 Not Found"]["\(code)"] ?? "\(code)"
                        var out = Data("HTTP/1.1 \(status)\r\nContent-Type: \(ctype)\r\nContent-Length: \(respBody.count)\r\nConnection: close\r\n\r\n".utf8)
                        out.append(respBody)
                        conn.send(content: out, completion: .contentProcessed { _ in conn.cancel() })
                        return
                    }
                }
                if done || err != nil { conn.cancel(); return }
                read()
            }
        }
        read()
    }
    listener.start(queue: .global())
    print("Survey sample on :\(PORT)  (control URL → \(BASE)/survey)")
    if SECRET.isEmpty { print("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).") }
}

startServer()
dispatchMain()

// VoicerOnePBX Programmable Voice — Example 2: Phone Survey (Go, stdlib only)
//
// A multi-step flow that keeps state across callbacks, keyed by the stable callId.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 go run main.go
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/survey
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"sync"
)

var (
	secret = os.Getenv("VOICER_SECRET")
	base   = envOr("VOICER_BASE_URL", "http://localhost:8080")
	port   = envOr("PORT", "8080")
)

type Verb map[string]any
type CCD []Verb

type Event struct {
	Event      string `json:"event"`
	CallID     string `json:"callId"`
	From       string `json:"from"`
	Digits     string `json:"digits"`
	Reason     string `json:"reason"`
	Transcript string `json:"transcript"`
}

// Per-call state, keyed by callId. In production this is a DB row; the KEY is what matters.
type response struct {
	From, Rating, Recommend, Comment string
}

var (
	mu        sync.Mutex
	responses = map[string]*response{}
)

// ── The handlers — this is the app ───────────────────────────────────────────

func handleStart(e Event) CCD {
	mu.Lock()
	responses[e.CallID] = &response{From: e.From}
	mu.Unlock()
	return CCD{
		{"say": map[string]any{"text": "Thanks for taking our two-question survey. " +
			"On a scale of 1 to 5, how satisfied were you with your call today? " +
			"Press a number from 1 to 5."}},
		{"gather": map[string]any{"numDigits": 1, "timeout": 8, "actionUrl": base + "/survey/q2"}},
	}
}

func handleQ2(e Event) CCD {
	mu.Lock()
	rec := responses[e.CallID]
	if rec != nil && e.Digits != "" {
		rec.Rating = e.Digits // ← state carried forward by callId
	}
	mu.Unlock()
	if rec == nil || e.Reason == "hangup" {
		return CCD{}
	}
	return CCD{
		{"say": map[string]any{"text": "Thank you. Would you recommend us to a friend? Press 1 for yes, 2 for no."}},
		{"gather": map[string]any{"numDigits": 1, "timeout": 8, "actionUrl": base + "/survey/q3"}},
	}
}

func handleQ3(e Event) CCD {
	mu.Lock()
	rec := responses[e.CallID]
	if rec != nil {
		rec.Recommend = map[string]string{"1": "yes", "2": "no"}[e.Digits]
		if rec.Recommend == "" {
			rec.Recommend = "unknown"
		}
	}
	mu.Unlock()
	if rec == nil || e.Reason == "hangup" {
		return CCD{}
	}
	return CCD{
		{"say": map[string]any{"text": "Last thing: leave any comments after the tone, then press pound. " +
			"Or press pound now to finish."}},
		{"record": map[string]any{"maxSeconds": 30, "finishOnKey": "#", "transcribe": true, "playBeep": true,
			"actionUrl": base + "/survey/done"}},
	}
}

func handleDone(e Event) CCD {
	mu.Lock()
	rec := responses[e.CallID]
	delete(responses, e.CallID)
	mu.Unlock()
	if rec != nil {
		rec.Comment = e.Transcript
		out, _ := json.Marshal(rec)
		log.Printf("  ✅ SURVEY COMPLETE: %s", out) // replace with a DB insert
	}
	return CCD{{"say": map[string]any{"text": "Thank you for your feedback. Goodbye."}}, {"hangup": map[string]any{}}}
}

var routes = map[string]func(Event) CCD{
	"/survey":      handleStart,
	"/survey/q2":   handleQ2,
	"/survey/q3":   handleQ3,
	"/survey/done": handleDone,
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

func verify(body []byte, h http.Header) bool {
	if secret == "" {
		return true
	}
	ts := h.Get("X-Voicer-Timestamp")
	sent := trimPrefix(h.Get("X-Voicer-Signature"), "sha256=")
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(ts + "."))
	mac.Write(body)
	return hmac.Equal([]byte(hex.EncodeToString(mac.Sum(nil))), []byte(sent))
}

func handle(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	if !verify(body, r.Header) {
		http.Error(w, `{"error":"bad signature"}`, http.StatusForbidden)
		return
	}
	fn, ok := routes[r.URL.Path]
	if !ok {
		http.Error(w, `{"error":"no such route"}`, http.StatusNotFound)
		return
	}
	var e Event
	_ = json.Unmarshal(body, &e)
	log.Printf("  → %s  event=%s digits=%q callId=%.8s", r.URL.Path, e.Event, e.Digits, e.CallID)
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(fn(e))
}

func main() {
	for p := range routes {
		http.HandleFunc(p, handle)
	}
	fmt.Printf("Survey sample on :%s  (control URL → %s/survey)\n", port, base)
	if secret == "" {
		fmt.Println("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).")
	}
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func envOr(k, def string) string {
	if v := os.Getenv(k); v != "" {
		return v
	}
	return def
}

func trimPrefix(s, p string) string {
	if len(s) >= len(p) && s[:len(p)] == p {
		return s[len(p):]
	}
	return s
}

// VoicerOnePBX Programmable Voice — Example 3: Spoken Support Search (Swift, stdlib only)
//
// The caller speaks a question; the backend searches a knowledge base and reads the answer back.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
// Uses only system frameworks (Foundation, Network, CryptoKit) — no packages.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 swift main.swift
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/support

import Foundation
import Network
import CryptoKit

let SECRET = ProcessInfo.processInfo.environment["VOICER_SECRET"] ?? ""
let BASE   = ProcessInfo.processInfo.environment["VOICER_BASE_URL"] ?? "http://localhost:8080"
let PORT   = UInt16(ProcessInfo.processInfo.environment["PORT"] ?? "8080") ?? 8080

typealias Verb = [String: Any]
typealias CCD = [Verb]

// A toy knowledge base. Swap for a DB full-text query, a vector store, or an LLM call — text in, answer out.
let kb: [(keywords: [String], answer: String)] = [
    (["hours", "open", "close", "time"],
     "We are open Monday to Friday, 9 A M to 6 P M Eastern, and closed on weekends."),
    (["password", "reset", "login", "sign in"],
     "To reset your password, visit acme dot com slash reset and follow the emailed link."),
    (["refund", "return", "money back"],
     "Refunds are processed within 5 business days to your original payment method."),
    (["shipping", "delivery", "track", "order"],
     "Standard shipping takes 3 to 5 business days. You will get a tracking link by email once it ships."),
    (["cancel", "subscription", "unsubscribe"],
     "You can cancel any time from Account, then Billing, then Cancel Subscription."),
]

func searchKB(_ query: String) -> String? {
    let q = query.lowercased()
    var best: String?; var bestScore = 0
    for entry in kb {
        let score = entry.keywords.reduce(0) { $0 + (q.contains($1) ? 1 : 0) }
        if score > bestScore { best = entry.answer; bestScore = score }
    }
    return best
}

// ── The handlers — this is the app ───────────────────────────────────────────

func handleStart(_ e: [String: Any]) -> CCD {
    [
        ["say": ["text": "Welcome to Acme support. After the tone, ask your question in a few words. "
                       + "For example, what are your hours, or how do I reset my password."]],
        // input:"speech" → the PBX records + transcribes on-device, returning the text in `speech`.
        ["gather": ["input": "speech", "speechTimeout": 8, "actionUrl": "\(BASE)/support/search"]],
    ]
}

func handleSearch(_ e: [String: Any]) -> CCD {
    if (e["reason"] as? String) == "hangup" { return [] }
    let query = (e["speech"] as? String ?? "").trimmingCharacters(in: .whitespaces)
    if query.isEmpty {
        return [["say": ["text": "Sorry, I didn't catch that."]],
                ["redirect": ["url": "\(BASE)/support"]]]
    }
    guard let answer = searchKB(query) else {
        return [["say": ["text": "I heard: \(query). I couldn't find an answer to that. "
                               + "Let me connect you with someone who can help."]],
                ["route": ["to": "support"]]]
    }
    print("  🔎 query=\"\(query)\" → answered")
    return [
        ["say": ["text": "Here's what I found. \(answer)"]],
        ["say": ["text": "To ask another question press 1, to speak to an agent press 2, "
                       + "or you can hang up. Thanks for calling."]],
        ["gather": ["numDigits": 1, "timeout": 6, "actionUrl": "\(BASE)/support/after"]],
    ]
}

func handleAfter(_ e: [String: Any]) -> CCD {
    if (e["reason"] as? String) == "hangup" { return [] }
    switch e["digits"] as? String ?? "" {
    case "1": return [["redirect": ["url": "\(BASE)/support"]]]
    case "2": return [["say": ["text": "Connecting you to an agent."]], ["route": ["to": "support"]]]
    default:  return [["say": ["text": "Thanks for calling Acme support. Goodbye."]], ["hangup": [:]]]
    }
}

func route(path: String, event: [String: Any]) -> CCD? {
    switch path {
    case "/support":        return handleStart(event)
    case "/support/search": return handleSearch(event)
    case "/support/after":  return handleAfter(event)
    default:                return nil
    }
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

func verify(body: Data, headers: [String: String]) -> Bool {
    if SECRET.isEmpty { return true }
    let ts = headers["x-voicer-timestamp"] ?? ""
    let sent = (headers["x-voicer-signature"] ?? "").replacingOccurrences(of: "sha256=", with: "")
    var msg = Data("\(ts).".utf8); msg.append(body)
    let mac = HMAC<SHA256>.authenticationCode(for: msg, using: SymmetricKey(data: Data(SECRET.utf8)))
    let hexStr = mac.map { String(format: "%02x", $0) }.joined()
    guard hexStr.utf8.count == sent.utf8.count else { return false }
    var diff: UInt8 = 0
    for (a, b) in zip(hexStr.utf8, sent.utf8) { diff |= a ^ b }
    return diff == 0
}

func appHandler(path: String, headers: [String: String], body: Data) -> (Int, String, Data) {
    if !verify(body: body, headers: headers) {
        return (403, "application/json", Data(#"{"error":"bad signature"}"#.utf8))
    }
    let event = (try? JSONSerialization.jsonObject(with: body)) as? [String: Any] ?? [:]
    print("  → \(path)  event=\(event["event"] ?? "") speech=\(event["speech"] ?? "") digits=\(event["digits"] ?? "")")
    guard let ccd = route(path: path, event: event) else {
        return (404, "application/json", Data(#"{"error":"no such route"}"#.utf8))
    }
    let data = (try? JSONSerialization.data(withJSONObject: ccd)) ?? Data("[]".utf8)
    return (200, "application/json", data)
}

func startServer() {
    let listener = try! NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: PORT)!)
    listener.newConnectionHandler = { conn in
        conn.start(queue: .global())
        var buf = Data()
        func read() {
            conn.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, done, err in
                if let data = data { buf.append(data) }
                if let hdrEnd = buf.range(of: Data("\r\n\r\n".utf8)) {
                    let head = String(data: buf.subdata(in: 0..<hdrEnd.lowerBound), encoding: .utf8) ?? ""
                    let lines = head.components(separatedBy: "\r\n")
                    let reqParts = lines.first?.components(separatedBy: " ") ?? []
                    let path = reqParts.count > 1 ? reqParts[1] : "/"
                    var headers = [String: String]()
                    for l in lines.dropFirst() {
                        if let c = l.firstIndex(of: ":") {
                            headers[l[..<c].trimmingCharacters(in: .whitespaces).lowercased()] =
                                l[l.index(after: c)...].trimmingCharacters(in: .whitespaces)
                        }
                    }
                    let clen = Int(headers["content-length"] ?? "0") ?? 0
                    let bodyStart = hdrEnd.upperBound
                    if buf.count - bodyStart >= clen {
                        let body = buf.subdata(in: bodyStart..<(bodyStart + clen))
                        let (code, ctype, respBody) = appHandler(path: path, headers: headers, body: body)
                        let status = ["200": "200 OK", "403": "403 Forbidden", "404": "404 Not Found"]["\(code)"] ?? "\(code)"
                        var out = Data("HTTP/1.1 \(status)\r\nContent-Type: \(ctype)\r\nContent-Length: \(respBody.count)\r\nConnection: close\r\n\r\n".utf8)
                        out.append(respBody)
                        conn.send(content: out, completion: .contentProcessed { _ in conn.cancel() })
                        return
                    }
                }
                if done || err != nil { conn.cancel(); return }
                read()
            }
        }
        read()
    }
    listener.start(queue: .global())
    print("Support-search sample on :\(PORT)  (control URL → \(BASE)/support)")
    if SECRET.isEmpty { print("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).") }
}

startServer()
dispatchMain()

// VoicerOnePBX Programmable Voice — Example 3: Spoken Support Search (Go, stdlib only)
//
// The caller speaks a question; the backend searches a knowledge base and reads the answer back.
// See ../python/app.py for the fully-commented reference; this is the same flow, terser.
//
// Run:  VOICER_SECRET=… VOICER_BASE_URL=http://<lan-ip>:8080 go run main.go
// Point the PBX endpoint's control URL at:  http://<lan-ip>:8080/support
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strings"
)

var (
	secret = os.Getenv("VOICER_SECRET")
	base   = envOr("VOICER_BASE_URL", "http://localhost:8080")
	port   = envOr("PORT", "8080")
)

type Verb map[string]any
type CCD []Verb

type Event struct {
	Event  string `json:"event"`
	CallID string `json:"callId"`
	Digits string `json:"digits"`
	Speech string `json:"speech"`
	Reason string `json:"reason"`
}

// A toy knowledge base. Swap for a DB full-text query, a vector store, or an LLM call — text in, answer out.
var kb = []struct {
	keywords []string
	answer   string
}{
	{[]string{"hours", "open", "close", "time"},
		"We are open Monday to Friday, 9 A M to 6 P M Eastern, and closed on weekends."},
	{[]string{"password", "reset", "login", "sign in"},
		"To reset your password, visit acme dot com slash reset and follow the emailed link."},
	{[]string{"refund", "return", "money back"},
		"Refunds are processed within 5 business days to your original payment method."},
	{[]string{"shipping", "delivery", "track", "order"},
		"Standard shipping takes 3 to 5 business days. You will get a tracking link by email once it ships."},
	{[]string{"cancel", "subscription", "unsubscribe"},
		"You can cancel any time from Account, then Billing, then Cancel Subscription."},
}

func searchKB(query string) (string, bool) {
	q := strings.ToLower(query)
	best, bestScore := "", 0
	for _, e := range kb {
		score := 0
		for _, k := range e.keywords {
			if strings.Contains(q, k) {
				score++
			}
		}
		if score > bestScore {
			best, bestScore = e.answer, score
		}
	}
	return best, bestScore > 0
}

// ── The handlers — this is the app ───────────────────────────────────────────

func handleStart(e Event) CCD {
	return CCD{
		{"say": map[string]any{"text": "Welcome to Acme support. After the tone, ask your question in a few words. " +
			"For example, what are your hours, or how do I reset my password."}},
		// input:"speech" → the PBX records + transcribes on-device, returning the text in `speech`.
		{"gather": map[string]any{"input": "speech", "speechTimeout": 8, "actionUrl": base + "/support/search"}},
	}
}

func handleSearch(e Event) CCD {
	if e.Reason == "hangup" {
		return CCD{}
	}
	query := strings.TrimSpace(e.Speech)
	if query == "" {
		return CCD{
			{"say": map[string]any{"text": "Sorry, I didn't catch that."}},
			{"redirect": map[string]any{"url": base + "/support"}},
		}
	}
	answer, ok := searchKB(query)
	if !ok {
		return CCD{
			{"say": map[string]any{"text": fmt.Sprintf("I heard: %s. I couldn't find an answer to that. "+
				"Let me connect you with someone who can help.", query)}},
			{"route": map[string]any{"to": "support"}},
		}
	}
	log.Printf("  🔎 query=%q → answered", query)
	return CCD{
		{"say": map[string]any{"text": "Here's what I found. " + answer}},
		{"say": map[string]any{"text": "To ask another question press 1, to speak to an agent press 2, " +
			"or you can hang up. Thanks for calling."}},
		{"gather": map[string]any{"numDigits": 1, "timeout": 6, "actionUrl": base + "/support/after"}},
	}
}

func handleAfter(e Event) CCD {
	if e.Reason == "hangup" {
		return CCD{}
	}
	switch e.Digits {
	case "1":
		return CCD{{"redirect": map[string]any{"url": base + "/support"}}}
	case "2":
		return CCD{{"say": map[string]any{"text": "Connecting you to an agent."}}, {"route": map[string]any{"to": "support"}}}
	default:
		return CCD{{"say": map[string]any{"text": "Thanks for calling Acme support. Goodbye."}}, {"hangup": map[string]any{}}}
	}
}

var routes = map[string]func(Event) CCD{
	"/support":        handleStart,
	"/support/search": handleSearch,
	"/support/after":  handleAfter,
}

// ── HTTP plumbing (generic; identical across the three examples) ──────────────

func verify(body []byte, h http.Header) bool {
	if secret == "" {
		return true
	}
	ts := h.Get("X-Voicer-Timestamp")
	sent := strings.TrimPrefix(h.Get("X-Voicer-Signature"), "sha256=")
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(ts + "."))
	mac.Write(body)
	return hmac.Equal([]byte(hex.EncodeToString(mac.Sum(nil))), []byte(sent))
}

func handle(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	if !verify(body, r.Header) {
		http.Error(w, `{"error":"bad signature"}`, http.StatusForbidden)
		return
	}
	fn, ok := routes[r.URL.Path]
	if !ok {
		http.Error(w, `{"error":"no such route"}`, http.StatusNotFound)
		return
	}
	var e Event
	_ = json.Unmarshal(body, &e)
	log.Printf("  → %s  event=%s speech=%q digits=%q", r.URL.Path, e.Event, e.Speech, e.Digits)
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(fn(e))
}

func main() {
	for p := range routes {
		http.HandleFunc(p, handle)
	}
	fmt.Printf("Support-search sample on :%s  (control URL → %s/support)\n", port, base)
	if secret == "" {
		fmt.Println("  ⚠️  VOICER_SECRET is empty — signature verification is DISABLED (dev only).")
	}
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func envOr(k, def string) string {
	if v := os.Getenv(k); v != "" {
		return v
	}
	return def
}