import Map    "mo:core/Map";
import Nat    "mo:core/Nat";
import OQL    "mo:caffeineai-oql";
import Expose "mo:caffeineai-oql/Expose";

actor {

  type Customer = { id : Nat; name : Text; country : Text; monthlyRevenueUsd : Nat };
  type Order    = { id : Nat; customerId : Nat; amountUsd : Nat; paid : Bool };

  let customers = Map.empty<Nat, Customer>();
  let orders    = Map.empty<Nat, Order>();

  include Expose({
    entities = [
      customers.toEntity("customer", "Customer", "id")
        .sample({ id = 0; name = ""; country = ""; monthlyRevenueUsd = 0 })
        .build(),

      orders.toEntity("order", "Order", "id")
        .sample({ id = 0; customerId = 0; amountUsd = 0; paid = false })
        // `customerId` points at the customer entity's primary key:
        .edge("customerId", "customer")
        .build(),
    ];
    // Access is decided by three functions. controllerOnly lets the platform
    // (a controller) read every row; everyone else is denied. isPublic stays
    // false so the data is not world-readable, and there is no token scheme.
    isPublic       = func () : Bool = false;
    authorizeUser  = OQL.Auth.controllerOnly;
    authorizeToken = OQL.Auth.noExternalTokens;
  });

  public shared func addCustomer(c : Customer) : async () { customers.add(c.id, c) };
  public shared func addOrder(o : Order)       : async () { orders.add(o.id, o) };
};

public type Access = { #deny; #unrestricted; #scoped : Principal };

isPublic()                 -- the whole surface is open (#unrestricted)
authorizeUser(caller)      -- principal-based policy
<minted token>             -- bearer token from oqlMintToken; its owner is the scope
authorizeToken(token)      -- your own token scheme

let admins : Set.Set<Principal> = Set.empty();
authorizeUser = func (p : Principal) : OQL.Auth.Access =
  if (p.isController() or admins.contains(p)) #unrestricted
  else if (p.isAnonymous()) #deny
  else #scoped p;   // every other signed-in user sees only their own rows

// `allowedUsers : Map<Principal, ()>` is your own actor state.
docs.toEntity("doc", "Doc", "id")
  .ownedByWith("owner", func (caller, owner) =
    allowedUsers.get(caller) != null            // listed → see everything
    or owner == #text(caller.toText()))         // otherwise → only your own
  .build()

customers.toEntity(name, typeName, primaryKey)
  .sample(template)                        // optional, see below
  .edge(fieldName, targetEntity)           // re-tag an auto-derived field as FK
  .ownedBy(fieldName)                      // owner column → per-user scoping
  .ownedByWith(fieldName, canSee)          // ...with an app-defined predicate
  .domain(fieldName, [values])             // declare a field's allowed values
  .hidden(fieldName)                       // drop a field from the schema
  .build()

articles.toEntityManual<Article>(name, typeName, primaryKey)
  .payload(fieldName, extract : T -> V)    // V picks a _toRow instance
  .flatten(extract : T -> S)               // splice a nested record's fields in
  .domain (fieldName, [values])            // declare a field's allowed values
  .edge   (fieldName, targetEntity)        // tags a declared payload as FK
  .hidden (fieldName)                      // drops a declared payload
  .build()

// Author = { id : Nat; name : Text; address : Address; tags : [Text] }
// Address = { city : Text; country : Text; postalCode : Text }
authors.toEntityManual<Author>("author", "Author", "id")
  .payload("id",   func a = a.id)
  .payload("name", func a = a.name)
  .flatten(func a = a.address)             // → city, country, postalCode columns
  .payload("tagCount", func a = a.tags.size())
  .build()

// DepartmentValue.mo — nested record → child's primary key
import OQL   "mo:caffeineai-oql";
import Types "Types";
module {
  public func _toRow(self : Types.Department) : OQL.Value = #text(self.name);
};

// OptTextValue.mo — optional field → pick a sentinel
import OQL "mo:caffeineai-oql";
module {
  public func _toRow(self : ?Text) : OQL.Value = switch self {
    case null { #text("") };
    case (?t) { #text(t) };
  };
};

// StatusValue.mo — variant → per-tag text
module {
  public func _toRow(self : Status) : OQL.Value = #text(switch self {
    case (#draft)     { "draft" };
    case (#published) { "published" };
    case (#archived)  { "archived" };
  });
};

// metrics : Map<Int (bucket), Map<Nat (sensor), Measurement>>
type MeasurementRow = { bucket : Int; sensor : Nat; metric : Text; value : Nat; okay : Bool };

OQL.Entity.new<MeasurementRow>(
  "measurement", func () = flattenMetrics(metrics), "MeasurementRow", "sensor",
)
  .edge("bucket", "bucket")
  .edge("sensor", "sensor")
  .build()

// articlesByAuthor : Map<Author, List<Article>> already exists
OQL.Entity.manual<Author>("author", func () = articlesByAuthor.keys(), "Author", "id")
  .payload("id",   func a = a.id)
  .payload("name", func a = a.name)
  .flatten(func a = a.address)
  .build()

// Article = { id : Nat; tags : [Text]; ... }
OQL.Entity.manual<(Article, Text)>(
  "articleTag", func () = flattenArticleTags(articles), "Pair", "pair",
)
  .payload("article", func ((a, _)) = a.id)
  .edge   ("article", "article")
  .payload("tag",     func ((_, t)) = t)
  .edge   ("tag",     "tag")
  .build()

func optText(o : ?Text) : Text = switch o { case null ""; case (?t) t };
func optNat(o : ?Nat)   : Nat  = switch o { case null 0;  case (?n) n };
func statusText(s : Status) : Text = switch s {
  case (#draft) "draft"; case (#published) "published"; case (#archived) "archived";
};
func tagSummary(tags : [Text]) : Text = Text.join(tags.values(), ",");

.payload("terminationDate", func e = optText(e.terminationDate))
.payload("status",          func a = statusText(a.status))
.payload("tagCount",        func a = a.tags.size())
.payload("tagSummary",      func a = tagSummary(a.tags))