// Emma's Lemonade Stand

// 1. Create your group
const myStand = await createGroup({
  name: "Emma's Lemonade Stand",
  slug: "emmas-lemonade",
  type: "business",
});

// 2. You are the owner (a person)
const me = await createPerson({
  name: "Emma",
  role: "org_owner",
  groupId: myStand._id,
});

// 3. Create lemonade (a thing)
const lemonade = await createThing({
  type: "product",
  name: "Fresh Lemonade",
  groupId: myStand._id,
  properties: {
    price: 1.0,
    inventory: 20,
  },
});

// 4. Customer buys it (a connection)
await createConnection({
  from: customer._id,
  to: lemonade._id,
  type: "purchased",
  groupId: myStand._id,
});

// 5. Log the sale (an event)
await createEvent({
  type: "tokens_purchased",
  actor: customer._id,
  target: lemonade._id,
  groupId: myStand._id,
  metadata: { amount: 1.0, weather: "sunny" },
});

// 6. AI learns (knowledge)
// "Sunny days = more sales. Make 30 cups tomorrow!"

// Acme Corporation - Enterprise SaaS with Hierarchical Groups

// Top-level organization group
const acmeCorp = await createGroup({
  name: "Acme Corporation",
  slug: "acme-corp",
  type: "organization",
  plan: "enterprise",
  limits: {
    users: 100,
    storage: 1000, // GB
    apiCalls: 1000000,
  },
});

// Department groups (nested)
const engineering = await createGroup({
  name: "Engineering",
  slug: "engineering",
  type: "department",
  parentGroupId: acmeCorp._id,
});

const backend = await createGroup({
  name: "Backend Team",
  slug: "backend",
  type: "team",
  parentGroupId: engineering._id,
});

// Role-based access control
const ceo = await createPerson({
  name: "Jane CEO",
  role: "org_owner",
  groupId: acmeCorp._id,
});

// AI sales agent (a thing)
const salesAgent = await createThing({
  type: "sales_agent",
  name: "Acme Sales AI",
  groupId: acmeCorp._id,
  properties: {
    systemPrompt: "You are a friendly sales assistant...",
    temperature: 0.7,
  },
});

// Lead management (things + connections)
const lead = await createThing({
  type: "lead",
  name: "John Smith - Enterprise Lead",
  groupId: acmeCorp._id,
  properties: {
    email: "[email protected]",
    budget: 100000,
    status: "qualified",
  },
});

// AI agent follows up (connection + event)
await createConnection({
  from: salesAgent._id,
  to: lead._id,
  type: "communicated",
  groupId: acmeCorp._id,
  metadata: {
    protocol: "email",
    subject: "Following up on our conversation",
  },
});

await createEvent({
  type: "communication_event",
  actor: salesAgent._id,
  target: lead._id,
  groupId: acmeCorp._id,
  metadata: {
    protocol: "email",
    sentiment: "positive",
  },
});

// AI learns from all sales interactions (knowledge)
const context = await queryKnowledge({
  groupId: acmeCorp._id,
  query: "enterprise software objections pricing",
  k: 10,
});

const aiResponse = await generateResponse({
  context,
  prompt: "Address pricing concerns",
});

// Emma's Friend Circle - Social Groups

// Create friend circle
const emmasFriends = await createGroup({
  name: "Emma's Friends",
  slug: "emmas-friends",
  type: "social",
});

// Create event group (nested under friend circle)
const birthdayParty = await createGroup({
  name: "Birthday Party 2025",
  slug: "birthday-party-2025",
  type: "event",
  parentGroupId: emmasFriends._id,
  properties: {
    date: "2025-12-15",
    location: "Emma's House",
    capacity: 20,
  },
});

// Add friends to the circle
const alice = await createPerson({
  name: "Alice",
  role: "org_user",
  groupId: emmasFriends._id,
});

// Share photos (things) in the event group
const photo = await createThing({
  type: "media",
  name: "Birthday Cake Photo",
  groupId: birthdayParty._id,
  properties: {
    url: "https://cdn.example.com/photo.jpg",
    takenAt: Date.now(),
  },
});

// Track RSVPs (connections)
await createConnection({
  from: alice._id,
  to: birthdayParty._id,
  type: "member_of",
  groupId: birthdayParty._id,
  metadata: {
    rsvp: "yes",
    guestsCount: 1,
  },
});

// CoolDAO - Blockchain-Native Organization

// Create DAO group
const coolDAO = await createGroup({
  name: "CoolDAO",
  slug: "cool-dao",
  type: "dao",
  properties: {
    blockchain: "base",
    governanceToken: "COOL",
    treasuryAddress: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
  },
});

// Create treasury committee (nested)
const treasury = await createGroup({
  name: "Treasury",
  slug: "treasury",
  type: "committee",
  parentGroupId: coolDAO._id,
});

// Create governance committee (nested)
const governance = await createGroup({
  name: "Governance Committee",
  slug: "governance",
  type: "committee",
  parentGroupId: coolDAO._id,
});

// DAO member with token holdings
const member = await createPerson({
  name: "DAO Member",
  role: "org_user",
  groupId: coolDAO._id,
});

// Track token holdings (thing + connection)
const tokenHolding = await createThing({
  type: "token",
  name: "COOL Token Holding",
  groupId: coolDAO._id,
  properties: {
    symbol: "COOL",
    amount: 1000,
    chain: "base",
  },
});

await createConnection({
  from: member._id,
  to: tokenHolding._id,
  type: "holds_tokens",
  groupId: coolDAO._id,
});

// Governance proposal (thing)
const proposal = await createThing({
  type: "proposal",
  name: "Allocate 10% Treasury to Marketing",
  groupId: governance._id,
  properties: {
    proposer: member._id,
    status: "active",
    votesFor: 5000,
    votesAgainst: 2000,
    quorum: 10000,
  },
});

// Vote event
await createEvent({
  type: "vote_cast",
  actor: member._id,
  target: proposal._id,
  groupId: governance._id,
  metadata: {
    choice: "for",
    votingPower: 1000,
  },
});