import Vapor
import Fluent
import SwiftMsgpack
import JWT

struct ToolController: RouteCollection {
    func boot(routes: any RoutesBuilder) throws {
        let group = routes.grouped("tool")
        group.post("signup", use: self.signup)

    }

    @Sendable
    func signup(req: Request) async throws -> Response {
        let body = try req.content.decode(SignupReq.self, using: MsgPackDecoder())

        guard let udid = req.headers["udid"].first else {
            throw Abort(.badRequest)
        }

        guard
            let session = try await Session.query(on: req.db).filter(\.$id == body.access_token).first(),
            session.type == SessionType.ZAT
        else {
            throw Abort(.forbidden, reason: "Invalid access token")
        }
        let accountId = session.$account.id

        if try await Player.query(on: req.db).filter(\.$account.$id == accountId).first() == nil {
            guard let account = try await Account.query(on: req.db).filter(\.$id == accountId).first() else {
                throw Abort(.forbidden, reason: "Account ID does not exist")
            }
            // Create new Player
            let player = try Player.createDefault(account: account)
            try await player.save(on: req.db)
        }

        let viewerSession = try await Session.query(on: req.db)
            .filter(\.$account.$id == accountId)
            .filter(\.$type == .VIEWER)
            .first() ?? Session(accountId: accountId, expires: Date.now, type: .VIEWER)

        if (viewerSession.hasChanges) {
            try await viewerSession.save(on: req.db)
        }
        let response = Response(status:.ok)

        try response.content.encode(SignupRes(
            data_headers: DataHeadersRes(
                short_udid: 0,
                viewer_id: Int(try viewerSession.requireID())!,
                udid: udid,
                servertime: Int(Date.now.timeIntervalSince1970 * 100),
                result_code: 1
            ),
            data: []
        ), using: MsgPackEncoder())

        return response
    }
}

struct SignupReq: Content {
    let app_secret: String
    let access_token: String
    let storage_directory_path: String
    let app_admin: String
    let kakao_pid: String
    let device_id: Double
    let idp_code: String
}

struct DataHeadersRes: Content {
    let short_udid: Int
    let viewer_id: Int
    let udid: String
    let servertime: Int
    let result_code: Int
}

struct SignupRes: Content {
    let data_headers: DataHeadersRes
    let data: [String]
}